def ExecuteTrendFollowing(self, exchange, moneta, tool, risultato):
#Attention: static stoploss and dynamic stoploss cannot be activated simultaneously
tool.attivazione_stoploss_statico = 0 #with zero not activated, with 1 activated
tool.attivazione_stoploss_dinamico = 1 # with zero not activated, with 1 activated
tool.profitto = 0.4 #minimum percentage of profit
tool.stoploss_1 = 0.8 #percentage of stoploss
tool.stoploss_2 = 2.0 #second level stoploss percentage (not active for now)
tool.commissioni = 0.25 #percentage of fees in buy and sell
tool.nrtransizioni = 2000 #do not use
tool.stoploss_dinamico_moltiplicatore = 0.997 #multiplier of the trailing stop
tool.stoploss_dinamico_formula = "row.close * tool.stoploss_dinamico_moltiplicatore" #formula per il calcolo dello stoploss dinamico (trailing stop)
tool.attivazione_stoploss_dinamico_limiti = 1 #with zero not activated, with 1 activated. It works if dynamic stoploss is activated
tool.stoploss_dinamico_min_profitto = 0.30 #minimum profit compared to lastbuy if activated stoploss_dinamico_limiti
tool.stoploss_dinamico_max_perdita = 2 #max loss in percentage compared to lastbuy if activated stoploss_dinamico_limiti
tool.hours = 36 #timedelta from now
tool.periodo = '5m' #candlestick timeframe
self.nome = " Test Strategy Trend Following "
candle = candlestick.Candlestick()
self.df1 = candle.getCandle(exchange, moneta, tool.hours, tool.periodo)
moneta = moneta
exchange = exchange
self.df1 = self.df1.apply(pd.to_numeric)
#-------------Indicators and oscillators
self.df1['rsi'] = ta.RSI(self.df1.close.values, timeperiod=14)
self.df1['adx'] = ta.ADX(self.df1['high'].values,
self.df1['low'].values,
self.df1['close'].values,
timeperiod=14)
# Bollinger bands with qtpylib--------------------------------------
""" bollinger = qt.bollinger_bands(qt.typical_price(self.df1), window=20, stds=2)
self.df1['lower'] = bollinger['lower']
self.df1['middle'] = bollinger['mid']
self.df1['upper'] = bollinger['upper'] """
#------------------------------------------------------------------
# Bollinger bands with TA library
self.df1['upper'], self.df1['middle'], self.df1['lower'] = ta.BBANDS(
self.df1['close'].values, timeperiod=5,nbdevup=1,nbdevdn=1, matype=1)
self.df1['upper2'], self.df1['middle2'], self.df1[
'lower2'] = ta.BBANDS(self.df1['close'].values, timeperiod=5,nbdevup=1.6,nbdevdn=1.6, matype=1)
self.df1['upper3'], self.df1['middle3'], self.df1[
'lower3'] = ta.BBANDS(self.df1['close'].values, timeperiod=5,nbdevup=2,nbdevdn=2, matype=1)
#------------------------------------------------------------------
self.df1['PrezzoMed'] = self.df1['close'].mean()
self.df1['STDDEV'] = ta.STDDEV(self.df1['close'].values,
timeperiod=15,
nbdev=1)
self.df1['macd'], self.df1['macdsignal'], self.df1[
'macdhist'] = ta.MACD(self.df1.close.values,
fastperiod=12,
slowperiod=26,
signalperiod=9)
self.df1['minus_di'] = ta.MINUS_DI(self.df1['high'].values,
self.df1['low'].values,
self.df1['close'].values,
timeperiod=25)
self.df1['plus_di'] = ta.PLUS_DI(self.df1['high'].values,
self.df1['low'].values,
self.df1['close'].values,
timeperiod=25)
self.df1['sar'] = ta.SAR(self.df1['high'].values,
self.df1['low'].values,
acceleration=0,
maximum=0)
self.df1['mom'] = ta.MOM(self.df1['close'].values, timeperiod=14)
self.df1['atr'] = ta.ATR(self.df1['high'].values,
self.df1['low'].values,
self.df1['close'].values,
timeperiod=14)
self.df1['ema'] = ta.EMA(self.df1['close'].values, timeperiod=20)
self.df1['ema1'] = ta.EMA(self.df1['close'].values, timeperiod=28)
self.df1['ema2'] = ta.EMA(self.df1['close'].values, timeperiod=35)
self.df1['ema3'] = ta.EMA(self.df1['close'].values, timeperiod=48)
self.df1['ema50'] = ta.EMA(self.df1['close'].values, timeperiod=50)
self.df1['dema20']= ta.DEMA(self.df1['close'].values, timeperiod=20)
self.df1['dema50']= ta.DEMA(self.df1['close'].values, timeperiod=50)
self.df1['tema20']= ta.TEMA(self.df1['close'].values, timeperiod=5)
self.df1['tema50']= ta.TEMA(self.df1['close'].values, timeperiod=20)
self.df1['cci'] = ta.CCI(self.df1['high'].values,
self.df1['low'].values,
self.df1['close'].values,
timeperiod=14)
#ta lib moving average
self.df1['shortma']= ta.SMA(self.df1['close'].values, timeperiod=10)
self.df1['longma']= ta.SMA(self.df1['close'].values, timeperiod=20)
# MFI
self.df1['mfi'] = ta.MFI(self.df1['high'].values,self.df1['low'].values, self.df1['close'].values, self.df1['volume'].values, timeperiod=14)
# Stoch
self.df1['slowk'],self.df1['slowd'] = ta.STOCH(self.df1['high'].values,self.df1['low'].values, self.df1['close'].values)
# Hammer: values [0, 100] - pattern recognised
self.df1['CDLHAMMER'] = ta.CDLHAMMER(self.df1['open'].values,self.df1['high'].values,self.df1['low'].values, self.df1['close'].values)
# Inverted Hammer: values
self.df1['CDLINVERTEDHAMMER'] = ta.CDLINVERTEDHAMMER(self.df1['open'].values,self.df1['high'].values,self.df1['low'].values, self.df1['close'].values)
# Engulfing
self.df1['CDLENGULFING'] = ta.CDLENGULFING(self.df1['open'].values,self.df1['high'].values,self.df1['low'].values, self.df1['close'].values)
# Hiddake
self.df1['CDLHIKKAKE'] = ta.CDLHIKKAKE(self.df1['open'].values,self.df1['high'].values,self.df1['low'].values, self.df1['close'].values)
# Doji
self.df1['CDLDOJI'] = ta.CDLDOJI(self.df1['open'].values,self.df1['high'].values,self.df1['low'].values, self.df1['close'].values)
# DojiStar
self.df1['CDLDOJISTAR'] = ta.CDLDOJISTAR(self.df1['open'].values,self.df1['high'].values,self.df1['low'].values, self.df1['close'].values)
# Stoch fast
self.df1['fastk'], self.df1['fastd'] = ta.STOCHF(self.df1.high.values, self.df1.low.values, self.df1.close.values)
# Inverse Fisher transform on RSI, values [-1.0, 1.0] (https://goo.gl/2JGGoy)
rsi = 0.1 * (self.df1['rsi'] - 50)
self.df1['fisher_rsi'] =(np.exp(2 * rsi) - 1) / (np.exp(2 * rsi) + 1)
# EMA - Exponential Moving Average
self.df1['ema5'] = ta.EMA(self.df1.close.values, timeperiod=5)
self.df1['ema10'] = ta.EMA(self.df1.close.values, timeperiod=10)
self.df1['ema50'] = ta.EMA(self.df1.close.values, timeperiod=50)
self.df1['ema100'] = ta.EMA(self.df1.close.values, timeperiod=100)
# SMA - Simple Moving Average
self.df1['sma'] = ta.SMA(self.df1.close.values, timeperiod=40)
#-----------------------------------------------------------------------
self.df1['Sellsignal'] = 0
self.df1['Buysignal'] = 0
#---------------------example 1 strategy buy and sell ----------------------------------------
#-------------Buy conditions----------------------------------------------------------
""" self.df1.loc[(((
(self.df1['macd'] > self.df1['macdsignal']) &
(self.df1['cci'] <= -50.0)))),'BuySignal'] = 1 """
#-------------Sell conditions----------------------------------------------------------
""" self.df1.loc[(((
(self.df1['macd'] < self.df1['macdsignal']) &
(self.df1['cci'] >= 100.0)))),'SellSignal'] = -1 """
#------------------------example 2 strategy buy and sell---------------------------------------
#-------------Buy conditions----------------------------------------------------------
""" self.df1.loc[(((
(self.df1['adx'] > 25) &
(self.df1['mom'] < 0) &
(self.df1['minus_di'] > 25) &
(self.df1['plus_di'] < self.df1['minus_di'])))),'BuySignal'] = 1 """
#-------------Sell conditions----------------------------------------------------------
""" self.df1.loc[(((
(self.df1['adx'] > 25) &
(self.df1['mom'] > 0) &
(self.df1['minus_di'] > 25) &
(self.df1['plus_di'] > self.df1['minus_di'])))),'SellSignal'] = -1 """
# --------------------------------------------------------------------------
#example 3 strategy macd and midprice with qtpylib Sell & Buy
#-------------Sell conditions----------------------------------------------------------
self.df1.loc[(((
self.qt.crossed_below(self.df1['macd'], self.df1['macdsignal'])))), 'Sellsignal'] = -1
#-------------Buy conditions----------------------------------------------------------
self.df1.loc[(((
self.qt.crossed_above(self.df1['macd'], self.df1['macdsignal'])) & (self.df1['close'] < self.df1['PrezzoMed']))), 'Buysignal'] = 1
# --------------------------------------------------------------------------
#example 4 strategy Bollinger Bands with rsi
#-------------Buy conditions----------------------------------------------------------
""" self.df1.loc[
((self.df1['close'] < self.df1['lower']) &
(self.df1['rsi'] < 30)
),'Buysignal'] = 1
#-------------Sell conditions----------------------------------------------------------
self.df1.loc[
((self.df1['close']>self.df1['upper']) |
(self.df1['rsi'] > 70)
),'Sellsignal'] = -1 """
#---------------------------------------------------------------------------
#example 5 Bollinger Bands with rsi qtpylib library Sell & Buy
#-------------Buy conditions----------------------------------------------------------
""" self.df1.loc[
(
(self.df1['rsi'] < 30) &
(self.df1['close'] < self.df1['lower'])
),
'Buysignal'] = 1
#------------Sell conditions--------------------------------------------
self.df1.loc[
(
(self.df1['rsi'] > 70)
),
'Sellsignal'] = -1 """
# --------------------------------------------------------------------------
#example 6 strategy longma and shortma with qtpylib Sell & Buy
#-------------Sell conditions----------------------------------------------------------
""" self.df1.loc[(((
self.qt.crossed_below(self.df1['shortma'], self.df1['longma'])))), 'Sellsignal'] = -1
#-------------Buy and Sell conditions----------------------------------------------------------
self.df1.loc[(((
self.qt.crossed_above(self.df1['shortma'], self.df1['longma'])) & (self.df1['close'] < self.df1['PrezzoMed']))), 'Buysignal'] = 1
"""
#--------------------------------------------------------------------------
#example 7 strategy with qtpylib and TA-lib Sell & Buy
#-------------Buy conditions--------------------------------
""" self.df1.loc[
(
(self.df1['rsi'] < 28) &
(self.df1['rsi'] > 0) &
(self.df1['close'] < self.df1['sma']) &
(self.df1['fisher_rsi'] < -0.94) &
(self.df1['mfi'] < 16.0) &
(
(self.df1['ema50'] > self.df1['ema100']) |
(qt.crossed_above(self.df1['ema5'], self.df1['ema10']))
) &
(self.df1['fastd'] > self.df1['fastk']) &
(self.df1['fastd'] > 0)
),
'Buysignal'] = 1
#------------Sell conditions---------------------------------------------
self.df1.loc[
(
(self.df1['sar'] > self.df1['close']) &
(self.df1['fisher_rsi'] > 0.3)
),
'Sellsignal'] = -1 """
# ----------------------------------------------------------------------
#example 8 strategy - multiple indicators with pattern indicator HAMMER
#------------------Sell conditions--------------------------------------
""" self.df1.loc[
(
(self.df1['rsi'] < 30) &
(self.df1['slowk'] < 20) &
(self.df1['lower'] > self.df1['close']) &
(self.df1['CDLHAMMER'] == 100)
),
'Buysignal'] = 1
#---------------Buy conditions------------------------------------------
self.df1.loc[
(
(self.df1['sar'] > self.df1['close']) &
(self.df1['fisher_rsi'] > 0.3)
),
'Sellsignal'] = -1 """
# ----------------------------------------------------------------------
#example 9 strategy pattern strategy ENGULFING strategy Sell and Buy
#---------------Sell conditions------------------------------------------
""" print(self.df1['CDLENGULFING'].values)
self.df1.loc[
(
(self.df1['CDLENGULFING'].values < -99)
),
'Buysignal'] = 1
#---------------Buy conditions------------------------------------------
self.df1.loc[
(
(self.df1['CDLENGULFING'].values > 99)
),
'Sellsignal'] = -1 """
#---------------------------------------------------------------------------------
#example 10 strategy Bollinger Bands with rsi with technical indicators Sell & Buy
"""risultati_index_buy = self.df1.index[self.df1['CDLINVERTEDHAMMER'] == 100].tolist()
risultato_last_index = self.df1.index[-1]
if ((risultati_index_buy == None) or (risultato_last_index == None) or (risultato_last_index == '') or (len(risultati_index_buy) == 0)):
print('None Result')
else:
risultato_last_index = str(risultati_index_buy[-1])
risultato_last_index = risultato_last_index[:-3]
risultato_last_index = (str(risultato_last_index))[:-3] #rimozione dei tre caratteri
data1 = datetime.fromtimestamp(int(risultato_last_index))
data2 = datetime.fromtimestamp(int(risultato_last_index))
print(data2,data1)
print(self.df1)
#------------------Buy conditions----------------------------------
self.df1.loc[(
self.df1['CDLINVERTEDHAMMER'] == 100
),'CDLHIKKAKE_CLOSE'] = self.df1['close']
self.df1.loc[
(
(self.df1['close'] < self.df1['lower3'])
)
,'Buysignal'] = 1
#------------------Sell conditions----------------------------------
self.df1.loc[
(
self.qt.crossed_above(self.df1['dema20'], self.df1['dema50'])
),'Sellsignal'] = -1
"""
#----------------------------------------------------------------------
#example 11 strategy DOJISTAR strategy Sell and Buy
#---------------Buy conditions------------------------------------------
""" self.df1.loc[
(
(self.df1['CDLDOJISTAR'].values == -100)
),
'Buysignal'] = 1
#---------------Sell conditions----------------------------------------
self.df1.loc[
(
(self.df1['CDLHIKKAKE'].values == 200)
),
'Sellsignal'] = -1 """
#-----------------------------------------------------------------------
#example 12 strategy DEMA of EMA BuySignal and SellSignal
#---------------Buy conditions------------------------------------------
""" self.df1.loc[(((
self.qt.crossed_below(self.df1['ema50'], self.df1['dema200'])))), 'BuySignal'] = 1
#---------------Sell conditions------------------------------------------
self.df1.loc[
(
(self.df1['CDLHIKKAKE'].values > 99)
),
'Sellsignal'] = -1 """
#---------------------------trailing stoploss---------------------------
#example 1
#tool.stoploss_dinamico_formula = "row.close * tool.stoploss_dinamico_moltiplicatore" #formula for calculating dynamic stoploss (trailing stop)
#example 2
tool.stoploss_dinamico_formula = "row.ema3"
x = []
y = []
balance = []
lower_vect = []
lower2_vect = []
upper_vect = []
upper2_vect = []
pattern_vect = []
close_vect = []
buysignal_vect = []
sellsignal_vect = []
prezzmed_vect = []
stdev_vect = []
stoplosssignal_vect = []
stoplossprezzo_vect = []
ema_vect = []
ema_long_vect = []
ema_short_vect = []
date = []
volume_vect = []
macd_vect = []
macd_signal_vect = []
macd_hist_vect = []
atr_vect = []
rsi_vect = []
i = 0
for row in self.df1.itertuples():
a = row.Index / 1000.0
b = datetime.fromtimestamp(a)
self.stoploss = self.getStoploss(row, i, tool)
logging.info("-----------Loop line processing " + str(i))
logging.info("1) self.stoploss value = " + str(self.stoploss))
if (i > 0):
stoplossprezzo_vect.append(self.stoplossprezzo)
logging.info(
"2) Value of i greater than zero not first loop for i =" +
str(i))
logging.info("2.1) Value of self.stoplossprezzo = " +
str(self.stoplossprezzo))
else:
self.stoplossprezzo = row.close * 0.99
logging.info(
"2) Value of i equal to zero first loop for i = " + str(i))
stoplossprezzo_vect.append(self.stoplossprezzo)
logging.info("2.1) Value of self.stoplossprezzo = " +
str(self.stoplossprezzo))
if (self.stoploss == 1):
logging.info(
"3) self.stoploss value = 1 after getstoploss method ")
x.append(i)
y.append(row.close)
if (row.Sellsignal == 0
and self.stoploss == 0) or (row.Sellsignal == 1
and self.stoploss == 1):
logging.info("4) Value of self.stoploss before If for sell " +
str(self.stoploss))
logging.info("4.1) Value of row.Sellsignal " +
str(row.Sellsignal))
sellsignal_vect.append(np.nan)
stoplosssignal_vect.append(np.nan)
else:
if (self.stoploss == 1):
logging.info("5) self.stoploss value = 1 else before if ")
logging.info(
"5.1) Indication of sell in presence of self.stoploss = 1"
)
if (self.sell == 0) and (self.buy == 1):
logging.info(
"5.2) Sell with self.stoploss = 1 self.stoploss = "
+ str(self.stoploss))
logging.info(
"5.2.1) Sell with self.stoploss = 1 self.sell = " +
str(self.sell))
logging.info(
"5.2.2) Sell with self.stoploss = 1 self.buy = " +
str(self.buy))
#increases variable by 1 num_of_trades by one
self.nr_of_trades = self.nr_of_trades+1
sellsignal_vect.append(row.close)
stoplosssignal_vect.append(row.close)
percentualecommissioni = (
float(row.close) / 100) * float(tool.commissioni)
logging.info(
"5.3) Percentage of fees in presence of self.stoploss = 1"
+ str(percentualecommissioni))
balance.append(
[row.close - (percentualecommissioni), 1])
if ((row.close - percentualecommissioni) > self.lastbuy):
self.nr_positive_trades = self.nr_positive_trades +1
elif ((row.close - percentualecommissioni) < self.lastbuy):
self.nr_negative_trades = self.nr_negative_trades +1
else:
print('Non risulta positiva ne negativa')
self.totalecommissioni = self.totalecommissioni + percentualecommissioni
logging.info(
"5.4) Total fees in presence of self.stoploss = 1 "
+ str(self.totalecommissioni))
self.sell = 1
self.buy = 0
self.stoploss = 0
logging.info(
"5.5) Assign value zero to self.stoploss = " +
str(self.stoploss))
logging.info("5.6) Assign value 1 to self.sell = " +
str(self.sell))
logging.info("5.7) Assign value zero to self.buy = " +
str(self.buy))
else:
sellsignal_vect.append(np.nan)
stoplosssignal_vect.append(np.nan)
self.stoploss = 0
else:
stoplosssignal_vect.append(np.nan)
if ((self.sell == 0) and (self.buy == 1)
and (tool.attivazione_stoploss_dinamico == 0)):
logging.info(
"6.0) Sell normal not in the presence of dynamic stoploss"
)
logging.info("6.1) Value of self.sell: " +
str(self.sell))
logging.info("6.2) Value of self.buy: " +
str(self.buy))
logging.info(
"6.3) Dynamic stoploss activation parameter value: "
+ str(tool.attivazione_stoploss_dinamico))
price1 = float(self.lastbuy) + (
(float(self.lastbuy)) / 100) * float(tool.profitto)
logging.info("6.4) Value of self.lastbuy: " +
str(self.lastbuy))
logging.info("6.5) Price1 price of sell: " +
str(price1))
logging.info("6.6) Profit parameters: " +
str(tool.profitto))
if (float(row.close) > float(price1)):
logging.info(
"6.7) Sell in presence of row.close greater than value of price1"
)
logging.info("6.8) Value of row.close: " +
str(row.close))
logging.info("6.9) Value of sell price: " +
str(price1))
#increases variable by 1 num_of_trades by one
self.nr_positive_trades = self.nr_positive_trades +1
sellsignal_vect.append(row.close)
percentualecommissioni = (float(
row.close) / 100) * float(tool.commissioni)
logging.info(
"6.9.1) Percentage of fees in presence of self.stoploss = 1 "
+ str(percentualecommissioni))
balance.append(
[row.close - (percentualecommissioni), 1])
self.totalecommissioni = self.totalecommissioni + percentualecommissioni
logging.info(
"6.9.2) Total of fees in presence of self.stoploss = 1"
+ str(self.totalecommissioni))
self.sell = 1
self.buy = 0
self.stoploss = 0
logging.info(
"6.9.3) Assign value zero to self.stoploss = "
+ str(self.stoploss))
logging.info(
"6.9.4) Assign value 1 to self.sell = " +
str(self.sell))
logging.info(
"6.9.5) Assign value 0 to self.buy = " +
str(self.buy))
else:
sellsignal_vect.append(np.nan)
else:
sellsignal_vect.append(np.nan)
if ((row.Buysignal == 0 or row.Buysignal == '0')):
logging.info(
"7) Value of self.stoploss in if row.BuySignal = 0 " +
str(self.stoploss))
logging.info("7.1) Value of row.Buysignal " +
str(row.Buysignal))
buysignal_vect.append(np.nan)
else:
if ((row.Buysignal == 1 or row.Buysignal == '1')):
logging.info("8) Value of row.Buysignal " +
str(row.Buysignal))
if (self.buy == '0' or self.buy == 0):
logging.info(
"8.1) Buy in presence of self.stoploss = " +
str(self.stoploss))
logging.info("8.2) Value of self.sell = " +
str(self.sell))
logging.info("8.3) Value of self.buy = " +
str(self.buy))
buysignal_vect.append(row.close)
percentualecommissioni = (
float(row.close) / 100) * float(tool.commissioni)
logging.info(
"8.4) Percentage of fees in presence of self.stoploss = 1 "
+ str(percentualecommissioni))
self.totalecommissioni = self.totalecommissioni + percentualecommissioni
logging.info(
"8.5) Total of fees in presence of stoploss = 1" +
str(self.totalecommissioni))
balance.append([(-row.close - percentualecommissioni),
0])
self.buy = 1
self.sell = 0
logging.info(
"8.5.1) Assign value zero to self.stoploss = " +
str(self.stoploss))
logging.info(
"8.5.2) Assign value zero to self.sell = " +
str(self.sell))
logging.info("8.5.3) Assign value 1 to self.buy = " +
str(self.buy))
if (tool.attivazione_stoploss_dinamico == 1):
logging.info(
"8.6) Value of tool.attivazione_stoploss_dinamico equal to : "
+ str(tool.attivazione_stoploss_dinamico))
self.stoplossprezzo = eval(
tool.stoploss_dinamico_formula)
logging.info(
"8.6.1) Value of self.stoplossprezzo " +
str(self.stoplossprezzo))
else:
self.stoplossprezzo = (row.close - (
(row.close / 100) * tool.stoploss_1))
logging.info(
"8.7) Value of self.stoplossprezzo with tool.attivazione_stoploss_dinamico equal to 1 = "
+ str(self.stoplossprezzo))
self.lastbuy = row.close
logging.info("8.8) Value of self.lastbuy" +
str(self.lastbuy))
logging.info("8.9.0) Value of self.stoploss = " +
str(self.stoploss))
logging.info("8.9.1) Value of self.sell = " +
str(self.sell))
logging.info("8.9.2) Value of self.buy = " +
str(self.buy))
logging.info("8.9.3) Value of self.stoplossprezzo = " +
str(self.stoplossprezzo))
logging.info("8.9.4) Value of self.lastbuy = " +
str(self.lastbuy))
logging.info(
"8.9.5) Value of tool.attivazione_stoploss_dinamico = "
+ str(tool.attivazione_stoploss_dinamico))
logging.info(
"8.9.6) Value of tool.attivazione_stoploss_statico = "
+ str(tool.attivazione_stoploss_statico))
else:
buysignal_vect.append(np.nan)
else:
buysignal_vect.append(np.nan)
#add indicators,oscillators and others
prezzmed_vect.append(row.PrezzoMed)
stdev_vect.append(row.STDDEV)
ema_vect.append(row.ema3)
date.append(b)
rsi_vect.append(row.rsi)
#pattern_vect.append(row.CDLHIKKAKE_CLOSE)
volume_vect.append(row.volume)
lower2_vect.append(row.lower2)
upper2_vect.append(row.upper2)
ema_long_vect.append(row.tema50)
ema_short_vect.append(row.tema20)
lower_vect.append(row.lower)
upper_vect.append(row.upper)
macd_vect.append(row.macd)
macd_signal_vect.append(row.macdsignal)
macd_hist_vect.append(row.macdhist)
atr_vect.append(row.atr)
i = i + 1
self.valorestrategia = self.getValoreStrategia(balance)
tool.setVisualizzaGrafico(1)
if (tool.visualizzagrafico == 1 or tool.visualizzagrafico == '1'):
ds = draw.Draw()
ds.setNrGrafici(2)
ds.draw_graphic(moneta, x, y, self.nr_of_trades, self.nr_positive_trades,self.nr_negative_trades, buysignal_vect, sellsignal_vect,
prezzmed_vect, stoplossprezzo_vect, stdev_vect,
self.nome, self.valorestrategia, date, ema_vect,
rsi_vect,pattern_vect,volume_vect,lower2_vect,
upper2_vect,ema_short_vect,ema_long_vect,lower_vect,upper_vect,macd_vect,macd_signal_vect,macd_hist_vect,atr_vect)
def CDLDOJI(DataFrame):
res = talib.CDLDOJI(DataFrame.open.values, DataFrame.high.values,
DataFrame.low.values, DataFrame.close.values)
return pd.DataFrame({'CDLDOJI': res}, index=DataFrame.index)
def appendAllTAData(df=pd.DataFrame([])):
resDF = pd.DataFrame([])
# 函数名：AD名称：ChaikinA/DLine累积/派发线（Accumulation/DistributionLine）
# 简介：MarcChaikin提出的一种平衡交易量指标，以当日的收盘价位来估算成交流量，用于估定一段时间内该证券累积的资金流量。
# 计算公式：A/D=昨日A/D+多空对比*今日成交量多空对比=[（收盘价-最低价）-（最高价-收盘价）]/（最高价-最低价）
# 若最高价等于最低价：多空对比=（收盘价/昨收盘）-1
# 研判：1、A/D测量资金流向，向上的A/D表明买方占优势，而向下的A/D表明卖方占优势
# 2、A/D与价格的背离可视为买卖信号，即底背离考虑买入，顶背离考虑卖出
# 3、应当注意A/D忽略了缺口的影响，事实上，跳空缺口的意义是不能轻易忽略的
# A/D指标无需设置参数，但在应用时，可结合指标的均线进行分析例子：real=AD(high,low,close,volume)
resDF['AD'] = ta.AD(df['max_price'].values, df['min_price'].values,
df['price'].values, df['vol'].values)
# 函数名：ADOSC名称：Chaikin A/D Oscillator Chaikin震荡指标
# 简介：将资金流动情况与价格行为相对比，检测市场中资金流入和流出的情况
# 计算公式：fastperiod A/D - slowperiod A/D
# 研判：1、交易信号是背离：看涨背离做多，看跌背离做空
# 2、股价与90天移动平均结合，与其他指标结合
# 3、由正变负卖出，由负变正买进
# 例子：real = ADOSC(high, low, close, volume, fastperiod=3, slowperiod=10)
resDF['ADOSC'] = ta.ADOSC(df['max_price'].values,
df['min_price'].values,
df['price'].values,
df['vol'].values,
fastperiod=3,
slowperiod=10)
resDF['ADX'] = ta.ADX(df['max_price'].values, df['min_price'].values,
df['price'].values)
resDF['ADXR'] = ta.ADXR(df['max_price'].values,
df['min_price'].values,
df['price'].values,
timeperiod=14)
resDF['APO'] = ta.APO(df['price'].values,
fastperiod=12,
slowperiod=26,
matype=0)
resDF['aroondown'], resDF['aroonup'] = ta.AROON(df['max_price'].values,
df['min_price'].values,
timeperiod=14)
resDF['AROONOSC'] = ta.AROONOSC(df['max_price'].values,
df['min_price'].values,
timeperiod=14)
resDF['ATR'] = ta.ATR(df['max_price'].values,
df['min_price'].values,
df['price'].values,
timeperiod=14)
resDF['AVGPRICE'] = ta.AVGPRICE(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values, df['price'].values)
resDF['upperband'], resDF['middleband'], resDF['lowerband'] = ta.BBANDS(
df['price'].values, timeperiod=5, nbdevup=2, nbdevdn=2, matype=0)
resDF['BETA'] = ta.BETA(df['max_price'].values,
df['min_price'].values,
timeperiod=5)
resDF['BOP'] = ta.BOP(df['price_today_open'].values,
df['max_price'].values, df['min_price'].values,
df['price'].values)
resDF['CCI'] = ta.CCI(df['max_price'].values,
df['min_price'].values,
df['price'].values,
timeperiod=10)[-1]
# 函数名：CDL2CROWS名称：Two Crows 两只乌鸦
# 简介：三日K线模式，第一天长阳，第二天高开收阴，第三天再次高开继续收阴，收盘比前一日收盘价低，预示股价下跌。
# 例子：integer = CDL2CROWS(open, high, low, close)
resDF['CDL2CROWS'] = ta.CDL2CROWS(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDL3BLACKCROWS名称：Three Black Crows 三只乌鸦
# 简介：三日K线模式，连续三根阴线，每日收盘价都下跌且接近最低价，每日开盘价都在上根K线实体内，预示股价下跌。
# 例子：integer = CD3BLACKCROWS(open, high, low, close)
resDF['CDL3BLACKCROWS'] = ta.CDL3BLACKCROWS(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDL3INSIDE名称： Three Inside Up/Down 三内部上涨和下跌
# 简介：三日K线模式，母子信号+长K线，以三内部上涨为例，K线为阴阳阳，第三天收盘价高于第一天开盘价，第二天K线在第一天K线内部，预示着股价上涨。
# 例子：integer = CDL3INSIDE(open, high, low, close)
resDF['CDL3INSIDE'] = ta.CDL3INSIDE(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDL3LINESTRIKE名称： Three-Line Strike 三线打击
# 简介：四日K线模式，前三根阳线，每日收盘价都比前一日高，开盘价在前一日实体内，第四日市场高开，收盘价低于第一日开盘价，预示股价下跌。
# 例子：integer = CDL3LINESTRIKE(open, high, low, close)
resDF['CDL3LINESTRIKE'] = ta.CDL3LINESTRIKE(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDL3OUTSIDE名称：Three Outside Up/Down 三外部上涨和下跌
# 简介：三日K线模式，与三内部上涨和下跌类似，K线为阴阳阳，但第一日与第二日的K线形态相反，以三外部上涨为例，第一日K线在第二日K线内部，预示着股价上涨。
# 例子：integer = CDL3OUTSIDE(open, high, low, close)
resDF['CDL3OUTSIDE'] = ta.CDL3OUTSIDE(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDL3STARSINSOUTH名称：Three Stars In The South 南方三星
# 简介：三日K线模式，与大敌当前相反，三日K线皆阴，第一日有长下影线，第二日与第一日类似，K线整体小于第一日，第三日无下影线实体信号，成交价格都在第一日振幅之内，预示下跌趋势反转，股价上升。
# 例子：integer = CDL3STARSINSOUTH(open, high, low, close)
resDF['CDL3STARSINSOUTH'] = ta.CDL3STARSINSOUTH(
df['price_today_open'].values, df['max_price'].values,
df['min_price'].values, df['price'].values)
# 函数名：CDL3WHITESOLDIERS名称：Three Advancing White Soldiers 三个白兵
# 简介：三日K线模式，三日K线皆阳，每日收盘价变高且接近最高价，开盘价在前一日实体上半部，预示股价上升。
# 例子：integer = CDL3WHITESOLDIERS(open, high, low, close)
resDF['CDL3WHITESOLDIERS'] = ta.CDL3WHITESOLDIERS(
df['price_today_open'].values, df['max_price'].values,
df['min_price'].values, df['price'].values)
# 函数名：CDLABANDONEDBABY名称：Abandoned Baby 弃婴
# 简介：三日K线模式，第二日价格跳空且收十字星（开盘价与收盘价接近，最高价最低价相差不大），预示趋势反转，发生在顶部下跌，底部上涨。
# 例子：integer = CDLABANDONEDBABY(open, high, low, close, penetration=0)
resDF['CDLABANDONEDBABY'] = ta.CDLABANDONEDBABY(
df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values,
penetration=0)
# 函数名：CDLADVANCEBLOCK名称：Advance Block 大敌当前
# 简介：三日K线模式，三日都收阳，每日收盘价都比前一日高，开盘价都在前一日实体以内，实体变短，上影线变长。
# 例子：integer = CDLADVANCEBLOCK(open, high, low, close)
resDF['CDLADVANCEBLOCK'] = ta.CDLADVANCEBLOCK(
df['price_today_open'].values, df['max_price'].values,
df['min_price'].values, df['price'].values)
# 函数名：CDLBELTHOLD名称：Belt-hold 捉腰带线
# 简介：两日K线模式，下跌趋势中，第一日阴线，第二日开盘价为最低价，阳线，收盘价接近最高价，预示价格上涨。
# 例子：integer = CDLBELTHOLD(open, high, low, close)
resDF['CDLBELTHOLD'] = ta.CDLBELTHOLD(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDLBREAKAWAY名称：Breakaway 脱离
# 简介：五日K线模式，以看涨脱离为例，下跌趋势中，第一日长阴线，第二日跳空阴线，延续趋势开始震荡，第五日长阳线，收盘价在第一天收盘价与第二天开盘价之间，预示价格上涨。
# 例子：integer = CDLBREAKAWAY(open, high, low, close)
resDF['CDLBREAKAWAY'] = ta.CDLBREAKAWAY(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名： CDLCLOSINGMARUBOZU 名称：Closing Marubozu 收盘缺影线
# 简介：一日K线模式，以阳线为例，最低价低于开盘价，收盘价等于最高价，预示着趋势持续。
# 例子：integer = CDLCLOSINGMARUBOZU(open, high, low, close)
resDF['CDLCLOSINGMARUBOZU'] = ta.CDLCLOSINGMARUBOZU(
df['price_today_open'].values, df['max_price'].values,
df['min_price'].values, df['price'].values)
# 函数名：CDLCONCEALBABYSWALL名称： Concealing Baby Swallow 藏婴吞没
# 简介：四日K线模式，下跌趋势中，前两日阴线无影线，第二日开盘、收盘价皆低于第二日，第三日倒锤头，第四日开盘价高于前一日最高价，收盘价低于前一日最低价，预示着底部反转。
# 例子：integer = CDLCONCEALBABYSWALL(open, high, low, close)
resDF['CDLCONCEALBABYSWALL'] = ta.CDLCONCEALBABYSWALL(
df['price_today_open'].values, df['max_price'].values,
df['min_price'].values, df['price'].values)
# 函数名：CDLCOUNTERATTACK
# 名称：Counterattack 反击线
# 简介：二日K线模式，与分离线类似。
# 例子：integer = CDLCOUNTERATTACK(open, high, low, close)
resDF['CDLCOUNTERATTACK'] = ta.CDLCOUNTERATTACK(
df['price_today_open'].values, df['max_price'].values,
df['min_price'].values, df['price'].values)
# 函数名：CDLDARKCLOUDCOVER名称：Dark Cloud Cover 乌云压顶
# 简介：二日K线模式，第一日长阳，第二日开盘价高于前一日最高价，收盘价处于前一日实体中部以下，预示着股价下跌。
# 例子：integer = CDLDARKCLOUDCOVER(open, high, low, close, penetration=0)
resDF['CDLDARKCLOUDCOVER'] = ta.CDLDARKCLOUDCOVER(
df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values,
penetration=0)
# 函数名： CDLDOJI
# 名称：Doji 十字
# 简介：一日K线模式，开盘价与收盘价基本相同。
# 例子：integer = CDLDOJI(open, high, low, close)
resDF['CDLDOJI'] = ta.CDLDOJI(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values, df['price'].values)
# 函数名： CDLDOJISTAR
# 名称：Doji Star 十字星
# 简介：一日K线模式，开盘价与收盘价基本相同，上下影线不会很长，预示着当前趋势反转。
# 例子：integer = CDLDOJISTAR(open, high, low, close)
resDF['CDLDOJISTAR'] = ta.CDLDOJISTAR(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDLDRAGONFLYDOJI名称：Dragonfly Doji 蜻蜓十字/T形十字
# 简介：一日K线模式，开盘后价格一路走低，之后收复，收盘价与开盘价相同，预示趋势反转。
# 例子：integer = CDLDRAGONFLYDOJI(open, high, low, close)
resDF['CDLDRAGONFLYDOJI'] = ta.CDLDRAGONFLYDOJI(
df['price_today_open'].values, df['max_price'].values,
df['min_price'].values, df['price'].values)
# 函数名：CDLENGULFING名称：Engulfing Pattern 吞噬模式
# 简介：两日K线模式，分多头吞噬和空头吞噬，以多头吞噬为例，第一日为阴线，第二日阳线，第一日的开盘价和收盘价在第二日开盘价收盘价之内，但不能完全相同。
# 例子：integer = CDLENGULFING(open, high, low, close)
resDF['CDLENGULFING'] = ta.CDLENGULFING(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDLEVENINGDOJISTAR名称：Evening Doji Star 十字暮星
# 简介：三日K线模式，基本模式为暮星，第二日收盘价和开盘价相同，预示顶部反转。
# 例子：integer = CDLEVENINGDOJISTAR(open, high, low, close, penetration=0)
resDF['CDLEVENINGDOJISTAR'] = ta.CDLEVENINGDOJISTAR(
df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values,
penetration=0)
# 函数名：CDLEVENINGSTAR名称：Evening Star 暮星
# 简介：三日K线模式，与晨星相反，上升趋势中，第一日阳线，第二日价格振幅较小，第三日阴线，预示顶部反转。
# 例子：integer = CDLEVENINGSTAR(open, high, low, close, penetration=0)
resDF['CDLEVENINGSTAR'] = ta.CDLEVENINGSTAR(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values,
penetration=0)
# 函数名：CDLGAPSIDESIDEWHITE名称：Up/Down-gap side-by-side white lines 向上/下跳空并列阳线
# 简介：二日K线模式，上升趋势向上跳空，下跌趋势向下跳空，第一日与第二日有相同开盘价，实体长度差不多，则趋势持续。
# 例子：integer = CDLGAPSIDESIDEWHITE(open, high, low, close)
resDF['CDLGAPSIDESIDEWHITE'] = ta.CDLGAPSIDESIDEWHITE(
df['price_today_open'].values, df['max_price'].values,
df['min_price'].values, df['price'].values)
# 函数名：CDLGRAVESTONEDOJI名称：Gravestone Doji 墓碑十字/倒T十字
# 简介：一日K线模式，开盘价与收盘价相同，上影线长，无下影线，预示底部反转。
# 例子：integer = CDLGRAVESTONEDOJI(open, high, low, close)
resDF['CDLGRAVESTONEDOJI'] = ta.CDLGRAVESTONEDOJI(
df['price_today_open'].values, df['max_price'].values,
df['min_price'].values, df['price'].values)
# 函数名：CDLHAMMER
# 名称：Hammer 锤头
# 简介：一日K线模式，实体较短，无上影线，下影线大于实体长度两倍，处于下跌趋势底部，预示反转。
# 例子：integer = CDLHAMMER(open, high, low, close)
resDF['CDLHAMMER'] = ta.CDLHAMMER(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDLHANGINGMAN
# 名称：Hanging Man 上吊线
# 简介：一日K线模式，形状与锤子类似，处于上升趋势的顶部，预示着趋势反转。
# 例子：integer = CDLHANGINGMAN(open, high, low, close)
resDF['CDLHANGINGMAN'] = ta.CDLHANGINGMAN(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDLHARAMI名称：Harami Pattern 母子线
# 简介：二日K线模式，分多头母子与空头母子，两者相反，以多头母子为例，在下跌趋势中，第一日K线长阴，第二日开盘价收盘价在第一日价格振幅之内，为阳线，预示趋势反转，股价上升。
# 例子：integer = CDLHARAMI(open, high, low, close)
resDF['CDLHARAMI'] = ta.CDLHARAMI(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDLHARAMICROSS名称：Harami Cross Pattern 十字孕线
# 简介：二日K线模式，与母子县类似，若第二日K线是十字线，便称为十字孕线，预示着趋势反转。
# 例子：integer = CDLHARAMICROSS(open, high, low, close)
resDF['CDLHARAMICROSS'] = ta.CDLHARAMICROSS(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDLHIGHWAVE
# 名称：High-Wave Candle 风高浪大线
# 简介：三日K线模式，具有极长的上/下影线与短的实体，预示着趋势反转。
# 例子：integer = CDLHIGHWAVE(open, high, low, close)
resDF['CDLHIGHWAVE'] = ta.CDLHIGHWAVE(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDLHIKKAKE名称：Hikkake Pattern 陷阱
# 简介：三日K线模式，与母子类似，第二日价格在前一日实体范围内，第三日收盘价高于前两日，反转失败，趋势继续。
# 例子：integer = CDLHIKKAKE(open, high, low, close)
resDF['CDLHIKKAKE'] = ta.CDLHIKKAKE(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDLHIKKAKEMOD名称：Modified Hikkake Pattern 修正陷阱
# 简介：三日K线模式，与陷阱类似，上升趋势中，第三日跳空高开；下跌趋势中，第三日跳空低开，反转失败，趋势继续。
# 例子：integer = CDLHIKKAKEMOD(open, high, low, close)
resDF['CDLHIKKAKEMOD'] = ta.CDLHIKKAKEMOD(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDLHOMINGPIGEON名称：Homing Pigeon 家鸽
# 简介：二日K线模式，与母子线类似，不同的的是二日K线颜色相同，第二日最高价、最低价都在第一日实体之内，预示着趋势反转。
# 例子：integer = CDLHOMINGPIGEON(open, high, low, close)
resDF['CDLHOMINGPIGEON'] = ta.CDLHOMINGPIGEON(
df['price_today_open'].values, df['max_price'].values,
df['min_price'].values, df['price'].values)
# 函数名：CDLIDENTICAL3CROWS名称：Identical Three Crows 三胞胎乌鸦
# 简介：三日K线模式，上涨趋势中，三日都为阴线，长度大致相等，每日开盘价等于前一日收盘价，收盘价接近当日最低价，预示价格下跌。
# 例子：integer = CDLIDENTICAL3CROWS(open, high, low, close)
resDF['CDLIDENTICAL3CROWS'] = ta.CDLIDENTICAL3CROWS(
df['price_today_open'].values, df['max_price'].values,
df['min_price'].values, df['price'].values)
# 函数名：CDLINNECK名称：In-Neck Pattern 颈内线
# 简介：二日K线模式，下跌趋势中，第一日长阴线，第二日开盘价较低，收盘价略高于第一日收盘价，阳线，实体较短，预示着下跌继续。
# 例子：integer = CDLINNECK(open, high, low, close)
resDF['CDLINNECK'] = ta.CDLINNECK(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDLINVERTEDHAMMER名称：Inverted Hammer 倒锤头
# 简介：一日K线模式，上影线较长，长度为实体2倍以上，无下影线，在下跌趋势底部，预示着趋势反转。
# 例子：integer = CDLINVERTEDHAMMER(open, high, low, close)
resDF['CDLINVERTEDHAMMER'] = ta.CDLINVERTEDHAMMER(
df['price_today_open'].values, df['max_price'].values,
df['min_price'].values, df['price'].values)
# 函数名：CDLKICKING
# 名称：Kicking 反冲形态
# 简介：二日K线模式，与分离线类似，两日K线为秃线，颜色相反，存在跳空缺口。
# 例子：integer = CDLKICKING(open, high, low, close)
resDF['CDLKICKING'] = ta.CDLKICKING(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDLKICKINGBYLENGTH名称：Kicking - bull/bear determined by the longer marubozu 由较长缺影线决定的反冲形态
# 简介：二日K线模式，与反冲形态类似，较长缺影线决定价格的涨跌。
# 例子：integer = CDLKICKINGBYLENGTH(open, high, low, close)
resDF['CDLKICKINGBYLENGTH'] = ta.CDLKICKINGBYLENGTH(
df['price_today_open'].values, df['max_price'].values,
df['min_price'].values, df['price'].values)
# 函数名：CDLLADDERBOTTOM名称：Ladder Bottom 梯底
# 简介：五日K线模式，下跌趋势中，前三日阴线，开盘价与收盘价皆低于前一日开盘、收盘价，第四日倒锤头，第五日开盘价高于前一日开盘价，阳线，收盘价高于前几日价格振幅，预示着底部反转。
# 例子：integer = CDLLADDERBOTTOM(open, high, low, close)
resDF['CDLLADDERBOTTOM'] = ta.CDLLADDERBOTTOM(
df['price_today_open'].values, df['max_price'].values,
df['min_price'].values, df['price'].values)
# 函数名：CDLLONGLEGGEDDOJI名称：Long Legged Doji 长脚十字
# 简介：一日K线模式，开盘价与收盘价相同居当日价格中部，上下影线长，表达市场不确定性。
# 例子：integer = CDLLONGLEGGEDDOJI(open, high, low, close)
resDF['CDLLONGLEGGEDDOJI'] = ta.CDLLONGLEGGEDDOJI(
df['price_today_open'].values, df['max_price'].values,
df['min_price'].values, df['price'].values)
# 函数名：CDLLONGLINE
# 名称：Long Line Candle 长蜡烛
# 简介：一日K线模式，K线实体长，无上下影线。
# 例子：integer = CDLLONGLINE(open, high, low, close)
resDF['CDLLONGLINE'] = ta.CDLLONGLINE(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDLMARUBOZU
# 名称：Marubozu 光头光脚/缺影线
# 简介：一日K线模式，上下两头都没有影线的实体，阴线预示着熊市持续或者牛市反转，阳线相反。
# 例子：integer = CDLMARUBOZU(open, high, low, close)
resDF['CDLMARUBOZU'] = ta.CDLMARUBOZU(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDLMATCHINGLOW名称：Matching Low 相同低价
# 简介：二日K线模式，下跌趋势中，第一日长阴线，第二日阴线，收盘价与前一日相同，预示底部确认，该价格为支撑位。
# 例子：integer = CDLMATCHINGLOW(open, high, low, close)
resDF['CDLMATCHINGLOW'] = ta.CDLMATCHINGLOW(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDLMATHOLD名称：Mat Hold 铺垫
# 简介：五日K线模式，上涨趋势中，第一日阳线，第二日跳空高开影线，第三、四日短实体影线，第五日阳线，收盘价高于前四日，预示趋势持续。
# 例子：integer = CDLMATHOLD(open, high, low, close, penetration=0)
resDF['CDLMATHOLD'] = ta.CDLMATHOLD(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values,
penetration=0)
# 函数名：CDLMORNINGDOJISTAR名称：Morning Doji Star 十字晨星
# 简介：三日K线模式，基本模式为晨星，第二日K线为十字星，预示底部反转。
# 例子：integer = CDLMORNINGDOJISTAR(open, high, low, close, penetration=0)
resDF['CDLMORNINGDOJISTAR'] = ta.CDLMORNINGDOJISTAR(
df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values,
penetration=0)
# 函数名：CDLMORNINGSTAR名称：Morning Star 晨星
# 简介：三日K线模式，下跌趋势，第一日阴线，第二日价格振幅较小，第三天阳线，预示底部反转。
# 例子：integer = CDLMORNINGSTAR(open, high, low, close, penetration=0)
resDF['CDLMORNINGSTAR'] = ta.CDLMORNINGSTAR(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values,
penetration=0)
# 函数名：CDLONNECK名称：On-Neck Pattern 颈上线
# 简介：二日K线模式，下跌趋势中，第一日长阴线，第二日开盘价较低，收盘价与前一日最低价相同，阳线，实体较短，预示着延续下跌趋势。
# 例子：integer = CDLONNECK(open, high, low, close)
resDF['CDLONNECK'] = ta.CDLONNECK(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDLPIERCING名称：Piercing Pattern 刺透形态
# 简介：两日K线模式，下跌趋势中，第一日阴线，第二日收盘价低于前一日最低价，收盘价处在第一日实体上部，预示着底部反转。
# 例子：integer = CDLPIERCING(open, high, low, close)
resDF['CDLPIERCING'] = ta.CDLPIERCING(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDLRICKSHAWMAN名称：Rickshaw Man 黄包车夫
# 简介：一日K线模式，与长腿十字线类似，若实体正好处于价格振幅中点，称为黄包车夫。
# 例子：integer = CDLRICKSHAWMAN(open, high, low, close)
resDF['CDLRICKSHAWMAN'] = ta.CDLRICKSHAWMAN(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDLRISEFALL3METHODS名称：Rising/Falling Three Methods 上升/下降三法
# 简介： 五日K线模式，以上升三法为例，上涨趋势中，第一日长阳线，中间三日价格在第一日范围内小幅震荡，第五日长阳线，收盘价高于第一日收盘价，预示股价上升。
# 例子：integer = CDLRISEFALL3METHODS(open, high, low, close)
resDF['CDLRISEFALL3METHODS'] = ta.CDLRISEFALL3METHODS(
df['price_today_open'].values, df['max_price'].values,
df['min_price'].values, df['price'].values)
# 函数名：CDLSEPARATINGLINES名称：Separating Lines 分离线
# 简介：二日K线模式，上涨趋势中，第一日阴线，第二日阳线，第二日开盘价与第一日相同且为最低价，预示着趋势继续。
# 例子：integer = CDLSEPARATINGLINES(open, high, low, close)
resDF['CDLSEPARATINGLINES'] = ta.CDLSEPARATINGLINES(
df['price_today_open'].values, df['max_price'].values,
df['min_price'].values, df['price'].values)
# 函数名：CDLSHOOTINGSTAR名称：Shooting Star 射击之星
# 简介：一日K线模式，上影线至少为实体长度两倍，没有下影线，预示着股价下跌
# 例子：integer = CDLSHOOTINGSTAR(open, high, low, close)
resDF['CDLSHOOTINGSTAR'] = ta.CDLSHOOTINGSTAR(
df['price_today_open'].values, df['max_price'].values,
df['min_price'].values, df['price'].values)
# 函数名：CDLSHORTLINE
# 名称：Short Line Candle 短蜡烛
# 简介：一日K线模式，实体短，无上下影线。
# 例子：integer = CDLSHORTLINE(open, high, low, close)
resDF['CDLSHORTLINE'] = ta.CDLSHORTLINE(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDLSPINNINGTOP
# 名称：Spinning Top 纺锤
# 简介：一日K线，实体小。
# 例子：integer = CDLSPINNINGTOP(open, high, low, close)
resDF['CDLSPINNINGTOP'] = ta.CDLSPINNINGTOP(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDLSTALLEDPATTERN名称：Stalled Pattern 停顿形态
# 简介：三日K线模式，上涨趋势中，第二日长阳线，第三日开盘于前一日收盘价附近，短阳线，预示着上涨结束。
# 例子：integer = CDLSTALLEDPATTERN(open, high, low, close)
resDF['CDLSTALLEDPATTERN'] = ta.CDLSTALLEDPATTERN(
df['price_today_open'].values, df['max_price'].values,
df['min_price'].values, df['price'].values)
# 函数名：CDLSTICKSANDWICH名称：Stick Sandwich 条形三明治
# 简介：三日K线模式，第一日长阴线，第二日阳线，开盘价高于前一日收盘价，第三日开盘价高于前两日最高价，收盘价于第一日收盘价相同。
# 例子：integer = CDLSTICKSANDWICH(open, high, low, close)
resDF['CDLSTICKSANDWICH'] = ta.CDLSTICKSANDWICH(
df['price_today_open'].values, df['max_price'].values,
df['min_price'].values, df['price'].values)
# 函数名：CDLTAKURI名称：Takuri (Dragonfly Doji with very long lower shadow) 探水竿
# 简介：一日K线模式，大致与蜻蜓十字相同，下影线长度长。
# 例子：integer = CDLTAKURI(open, high, low, close)
resDF['CDLTAKURI'] = ta.CDLTAKURI(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDLTASUKIGAP名称：Tasuki Gap 跳空并列阴阳线
# 简介：三日K线模式，分上涨和下跌，以上升为例，前两日阳线，第二日跳空，第三日阴线，收盘价于缺口中，上升趋势持续。
# 例子：integer = CDLTASUKIGAP(open, high, low, close)
resDF['CDLTASUKIGAP'] = ta.CDLTASUKIGAP(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDLTHRUSTING名称：Thrusting Pattern 插入
# 简介：二日K线模式，与颈上线类似，下跌趋势中，第一日长阴线，第二日开盘价跳空，收盘价略低于前一日实体中部，与颈上线相比实体较长，预示着趋势持续。
# 例子：integer = CDLTHRUSTING(open, high, low, close)
resDF['CDLTHRUSTING'] = ta.CDLTHRUSTING(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDLTRISTAR
# 名称：Tristar Pattern 三星
# 简介：三日K线模式，由三个十字组成，第二日十字必须高于或者低于第一日和第三日，预示着反转。
# 例子：integer = CDLTRISTAR(open, high, low, close)
resDF['CDLTRISTAR'] = ta.CDLTRISTAR(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDLUNIQUE3RIVER名称：Unique 3 River 奇特三河床
# 简介：三日K线模式，下跌趋势中，第一日长阴线，第二日为锤头，最低价创新低，第三日开盘价低于第二日收盘价，收阳线，收盘价不高于第二日收盘价，预示着反转，第二日下影线越长可能性越大。
# 例子：integer = CDLUNIQUE3RIVER(open, high, low, close)
resDF['CDLUNIQUE3RIVER'] = ta.CDLUNIQUE3RIVER(
df['price_today_open'].values, df['max_price'].values,
df['min_price'].values, df['price'].values)
# 函数名：CDLUPSIDEGAP2CROWS名称：Upside Gap Two Crows 向上跳空的两只乌鸦
# 简介：三日K线模式，第一日阳线，第二日跳空以高于第一日最高价开盘，收阴线，第三日开盘价高于第二日，收阴线，与第一日比仍有缺口。
# 例子：integer = CDLUPSIDEGAP2CROWS(open, high, low, close)
resDF['CDLUPSIDEGAP2CROWS'] = ta.CDLUPSIDEGAP2CROWS(
df['price_today_open'].values, df['max_price'].values,
df['min_price'].values, df['price'].values)
# 函数名：CDLXSIDEGAP3METHODS名称：Upside/Downside Gap Three Methods 上升/下降跳空三法
# 简介：五日K线模式，以上升跳空三法为例，上涨趋势中，第一日长阳线，第二日短阳线，第三日跳空阳线，第四日阴线，开盘价与收盘价于前两日实体内，第五日长阳线，收盘价高于第一日收盘价，预示股价上升。
# 例子：integer = CDLXSIDEGAP3METHODS(open, high, low, close)
resDF['CDLXSIDEGAP3METHODS'] = ta.CDLXSIDEGAP3METHODS(
df['price_today_open'].values, df['max_price'].values,
df['min_price'].values, df['price'].values)
resDF['CMO'] = ta.CMO(df['price'].values, timeperiod=14)
resDF['CORREL'] = ta.CORREL(df['max_price'].values,
df['min_price'].values,
timeperiod=30)
resDF['DEMA'] = ta.DEMA(df['price'].values, timeperiod=30)
resDF['DX'] = ta.DX(df['max_price'].values,
df['min_price'].values,
df['price'].values,
timeperiod=14)
resDF['EMA'] = ta.EMA(df['price'].values, timeperiod=30)
resDF['HT_DCPERIOD'] = ta.HT_DCPERIOD(df['price'].values)
resDF['HT_DCPHASE'] = ta.HT_DCPHASE(df['price'].values)
resDF['inphase'], resDF['quadrature'] = ta.HT_PHASOR(df['price'].values)
resDF['sine'], resDF['leadsine'] = ta.HT_SINE(df['price'].values)
resDF['HT_TRENDLINE'] = ta.HT_TRENDLINE(df['price'].values)
resDF['HT_TRENDMODE'] = ta.HT_TRENDMODE(df['price'].values)
resDF['KAMA'] = ta.KAMA(df['price'].values, timeperiod=30)
resDF['LINEARREG'] = ta.LINEARREG(df['price'].values, timeperiod=14)
resDF['LINEARREG_ANGLE'] = ta.LINEARREG_ANGLE(df['price'].values,
timeperiod=14)
resDF['LINEARREG_INTERCEPT'] = ta.LINEARREG_INTERCEPT(df['price'].values,
timeperiod=14)
resDF['LINEARREG_SLOPE'] = ta.LINEARREG_SLOPE(df['price'].values,
timeperiod=14)
resDF['MA'] = ta.MA(df['price'].values, timeperiod=30, matype=0)
resDF['macd'], resDF['macdsignal'], resDF['macdhist'] = ta.MACD(
df['price'].values, fastperiod=12, slowperiod=26, signalperiod=9)
resDF['macd'], resDF['macdsignal'], resDF['macdhist'] = ta.MACDEXT(
df['price'].values,
fastperiod=12,
fastmatype=0,
slowperiod=26,
slowmatype=0,
signalperiod=9,
signalmatype=0)
resDF['macd'], resDF['macdsignal'], resDF['macdhist'] = ta.MACDFIX(
df['price'].values, signalperiod=9)
#resDF['mama'], resDF['fama'] = ta.MAMA (df['price'].values, fastlimit=0, slowlimit=0)
resDF['MAX'] = ta.MAX(df['price'].values, timeperiod=30)
resDF['MAXINDEX'] = ta.MAXINDEX(df['price'].values, timeperiod=30)
resDF['MEDPRICE'] = ta.MEDPRICE(df['max_price'].values,
df['min_price'].values)
resDF['MFI'] = ta.MFI(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values,
timeperiod=14)
resDF['MIDPOINT'] = ta.MIDPOINT(df['price'].values, timeperiod=14)
resDF['MIDPRICE'] = ta.MIDPRICE(df['max_price'].values,
df['min_price'].values,
timeperiod=14)
resDF['MIN'] = ta.MIN(df['price'].values, timeperiod=30)
resDF['MININDEX'] = ta.MININDEX(df['price'].values, timeperiod=30)
resDF['min'], resDF['max'] = ta.MINMAX(df['price'].values, timeperiod=30)
resDF['minidx'], resDF['maxidx'] = ta.MINMAXINDEX(df['price'].values,
timeperiod=30)
resDF['MINUS_DI'] = ta.MINUS_DI(df['max_price'].values,
df['min_price'].values,
df['price'].values,
timeperiod=14)
resDF['MINUS_DM'] = ta.MINUS_DM(df['max_price'].values,
df['min_price'].values,
timeperiod=14)
resDF['MOM'] = ta.MOM(df['max_price'].values, timeperiod=10)
resDF['NATR'] = ta.NATR(df['max_price'].values,
df['min_price'].values,
df['price'].values,
timeperiod=14)
# 函数名：OBV 名称：On Balance Volume 能量潮
# 简介：Joe Granville提出，通过统计成交量变动的趋势推测股价趋势计算公式：以某日为基期，逐日累计每日上市股票总成交量，若隔日指数或股票上涨，则基期OBV加上本日成交量为本日OBV。隔日指数或股票下跌，则基期OBV减去本日成交量为本日OBV
# 研判：1、以“N”字型为波动单位，一浪高于一浪称“上升潮”，下跌称“跌潮”；上升潮买进，跌潮卖出
# 2、须配合K线图走势
# 3、用多空比率净额法进行修正，但不知TA-Lib采用哪种方法
# 多空比率净额= [（收盘价－最低价）－（最高价-收盘价）] ÷（ 最高价－最低价）×成交量
# 例子：real = OBV(close, volume)
resDF['OBV'] = ta.OBV(df['price'].values, df['vol'].values)
# resDF['PLUS_DI'] = ta.PLUS_DI
# resDF['PLUS_DM'] = ta.PLUS_DM
resDF['PPO'] = ta.PPO(df['price'].values,
fastperiod=12,
slowperiod=26,
matype=0)
resDF['ROC'] = ta.ROC(df['price'].values, timeperiod=10)
resDF['ROCP'] = ta.ROCP(df['price'].values, timeperiod=10)
resDF['ROCR'] = ta.ROCR(df['price'].values, timeperiod=10)
resDF['ROCR100'] = ta.ROCR100(df['price'].values, timeperiod=10)
resDF['RSI'] = ta.RSI(df['price'].values, timeperiod=14)
resDF['SAR'] = ta.SAR(df['max_price'].values,
df['min_price'].values,
acceleration=0,
maximum=0)
resDF['SAREXT'] = ta.SAREXT(df['max_price'].values,
df['min_price'].values,
startvalue=0,
offsetonreverse=0,
accelerationinitlong=0,
accelerationlong=0,
accelerationmaxlong=0,
accelerationinitshort=0,
accelerationshort=0,
accelerationmaxshort=0)
resDF['SMA'] = ta.SMA(df['price'].values, timeperiod=30)
resDF['STDDEV'] = ta.STDDEV(df['price'].values, timeperiod=5, nbdev=1)
# resDF['STOCH'] = ta.STOCH
# resDF['STOCHF'] = ta.STOCHF
resDF['fastk'], resDF['fastd'] = ta.STOCHRSI(df['price'].values,
timeperiod=14,
fastk_period=5,
fastd_period=3,
fastd_matype=0)
resDF['SUM'] = ta.SUM(df['price'].values, timeperiod=30)
resDF['T3'] = ta.T3(df['price'].values, timeperiod=5, vfactor=0)
resDF['TEMA'] = ta.TEMA(df['price'].values, timeperiod=30)
resDF['TRANGE'] = ta.TRANGE(df['max_price'].values, df['min_price'].values,
df['price'].values)
resDF['TRIMA'] = ta.TRIMA(df['price'].values, timeperiod=30)
resDF['TRIX'] = ta.TRIX(df['price'].values, timeperiod=30)
resDF['TSF'] = ta.TSF(df['price'].values, timeperiod=14)
resDF['TYPPRICE'] = ta.TYPPRICE(df['max_price'].values,
df['min_price'].values, df['price'].values)
# resDF['ULTOSC'] = ta.ULTOSC
resDF['VAR'] = ta.VAR(df['price'].values, timeperiod=5, nbdev=1)
resDF['WCLPRICE'] = ta.WCLPRICE(df['max_price'].values,
df['min_price'].values, df['price'].values)
# resDF['WILLR'] = ta.WILLR
resDF['WMA'] = ta.WMA(df['price'].values, timeperiod=30)
return resDF
df['CDL2CROWS'] = talib.CDL2CROWS(op, hp, lp, cp) df['CDL3BLACKCROWS'] = talib.CDL3BLACKCROWS(op, hp, lp, cp) df['CDL3INSIDE'] = talib.CDL3INSIDE(op, hp, lp, cp) df['CDL3LINESTRIKE'] = talib.CDL3LINESTRIKE(op, hp, lp, cp) df['CDL3OUTSIDE'] = talib.CDL3OUTSIDE(op, hp, lp, cp) df['CDL3STARSINSOUTH'] = talib.CDL3STARSINSOUTH(op, hp, lp, cp) df['CDL3WHITESOLDIERS'] = talib.CDL3WHITESOLDIERS(op, hp, lp, cp) df['CDLABANDONEDBABY'] = talib.CDLABANDONEDBABY(op, hp, lp, cp) df['CDLADVANCEBLOCK'] = talib.CDLADVANCEBLOCK(op, hp, lp, cp) df['CDLBELTHOLD'] = talib.CDLBELTHOLD(op, hp, lp, cp) df['CDLBREAKAWAY'] = talib.CDLBREAKAWAY(op, hp, lp, cp) df['CDLCLOSINGMARUBOZU'] = talib.CDLCLOSINGMARUBOZU(op, hp, lp, cp) df['CDLCONCEALBABYSWALL'] = talib.CDLCONCEALBABYSWALL(op, hp, lp, cp) df['CDLCOUNTERATTACK'] = talib.CDLCOUNTERATTACK(op, hp, lp, cp) df['CDLDARKCLOUDCOVER'] = talib.CDLDARKCLOUDCOVER(op, hp, lp, cp) df['CDLDOJI'] = talib.CDLDOJI(op, hp, lp, cp) df['CDLDOJISTAR'] = talib.CDLDOJISTAR(op, hp, lp, cp) df['CDLDRAGONFLYDOJI'] = talib.CDLDRAGONFLYDOJI(op, hp, lp, cp) df['CDLENGULFING'] = talib.CDLENGULFING(op, hp, lp, cp) df['CDLEVENINGDOJISTAR'] = talib.CDLEVENINGDOJISTAR(op, hp, lp, cp) df['CDLEVENINGSTAR'] = talib.CDLEVENINGSTAR(op, hp, lp, cp) df['CDLGAPSIDESIDEWHITE'] = talib.CDLGAPSIDESIDEWHITE(op, hp, lp, cp) df['CDLGRAVESTONEDOJI'] = talib.CDLGRAVESTONEDOJI(op, hp, lp, cp) df['CDLHAMMER'] = talib.CDLHAMMER(op, hp, lp, cp) df['CDLHANGINGMAN'] = talib.CDLHANGINGMAN(op, hp, lp, cp) df['CDLHARAMI'] = talib.CDLHARAMI(op, hp, lp, cp) df['CDLHARAMICROSS'] = talib.CDLHARAMICROSS(op, hp, lp, cp) df['CDLHIGHWAVE'] = talib.CDLHIGHWAVE(op, hp, lp, cp) df['CDLHIKKAKE'] = talib.CDLHIKKAKE(op, hp, lp, cp) df['CDLHIKKAKEMOD'] = talib.CDLHIKKAKEMOD(op, hp, lp, cp) df['CDLHOMINGPIGEON'] = talib.CDLHOMINGPIGEON(op, hp, lp, cp)
df['CDL2CROWS'] = talib.CDL2CROWS(open, high, low, close)
df['CDL3BLACKCROWS'] = talib.CDL3BLACKCROWS(open, high, low, close)
df['CDL3INSIDE'] = talib.CDL3INSIDE(open, high, low, close)
df['CDL3LINESTRIKE'] = talib.CDL3LINESTRIKE(open, high, low, close)
df['CDLBREAKAWAY'] = talib.CDLBREAKAWAY(open, high, low, close)
df['CDLADVANCEBLOCK'] = talib.CDLADVANCEBLOCK(open, high, low, close)
df['BETA'] = talib.BETA(high, low, timeperiod=5)
df['CORREL'] = talib.CORREL(high, low, timeperiod=30)
df['AD'] = talib.AD(high, low, close, volume)
df['TSF'] = talib.TSF(close, timeperiod=14)
df['CDLDARKCLOUDCOVER'] = talib.CDLDARKCLOUDCOVER(open,
high,
low,
close,
penetration=0)
df['CDLDOJI'] = talib.CDLDOJI(open, high, low, close)
df['CDLMORNINGDOJISTAR'] = talib.CDLMORNINGDOJISTAR(open,
high,
low,
close,
penetration=0)
df['CDLMORNINGSTAR'] = talib.CDLMORNINGSTAR(open,
high,
low,
close,
penetration=0)
df['CDLONNECK'] = talib.CDLONNECK(open, high, low, close)
df['CDLPIERCING'] = talib.CDLPIERCING(open, high, low, close)
df['CDLRICKSHAWMAN'] = talib.CDLRICKSHAWMAN(open, high, low, close)
df['CDLRISEFALL3METHODS'] = talib.CDLRISEFALL3METHODS(open, high, low, close)
df['CDLSEPARATINGLINES'] = talib.CDLSEPARATINGLINES(open, high, low, close)
def findPattern(self, data, dict, saveDict):
data = data.head(4)
data = data[::-1]
check = talib.CDLMORNINGSTAR(data['Open'], data['High'], data['Low'],
data['Close'])
if (check.tail(1).item() != 0):
dict[
'Pattern'] = colorText.BOLD + colorText.GREEN + 'Morning Star' + colorText.END
saveDict['Pattern'] = 'Morning Star'
return True
check = talib.CDLMORNINGDOJISTAR(data['Open'], data['High'],
data['Low'], data['Close'])
if (check.tail(1).item() != 0):
dict[
'Pattern'] = colorText.BOLD + colorText.GREEN + 'Morning Doji Star' + colorText.END
saveDict['Pattern'] = 'Morning Doji Star'
return True
check = talib.CDLEVENINGSTAR(data['Open'], data['High'], data['Low'],
data['Close'])
if (check.tail(1).item() != 0):
dict[
'Pattern'] = colorText.BOLD + colorText.FAIL + 'Evening Star' + colorText.END
saveDict['Pattern'] = 'Evening Star'
return True
check = talib.CDLEVENINGDOJISTAR(data['Open'], data['High'],
data['Low'], data['Close'])
if (check.tail(1).item() != 0):
dict[
'Pattern'] = colorText.BOLD + colorText.FAIL + 'Evening Doji Star' + colorText.END
saveDict['Pattern'] = 'Evening Doji Star'
return True
check = talib.CDLLADDERBOTTOM(data['Open'], data['High'], data['Low'],
data['Close'])
if (check.tail(1).item() != 0):
if (check.tail(1).item() > 0):
dict[
'Pattern'] = colorText.BOLD + colorText.GREEN + 'Ladder Bottom' + colorText.END
saveDict['Pattern'] = 'Bullish Ladder Bottom'
else:
dict[
'Pattern'] = colorText.BOLD + colorText.FAIL + 'Ladder Bottom' + colorText.END
saveDict['Pattern'] = 'Bearish Ladder Bottom'
return True
check = talib.CDL3LINESTRIKE(data['Open'], data['High'], data['Low'],
data['Close'])
if (check.tail(1).item() != 0):
if (check.tail(1).item() > 0):
dict[
'Pattern'] = colorText.BOLD + colorText.GREEN + '3 Line Strike' + colorText.END
else:
dict[
'Pattern'] = colorText.BOLD + colorText.FAIL + '3 Line Strike' + colorText.END
saveDict['Pattern'] = '3 Line Strike'
return True
check = talib.CDL3BLACKCROWS(data['Open'], data['High'], data['Low'],
data['Close'])
if (check.tail(1).item() != 0):
dict[
'Pattern'] = colorText.BOLD + colorText.FAIL + '3 Black Crows' + colorText.END
saveDict['Pattern'] = '3 Black Crows'
return True
check = talib.CDL3INSIDE(data['Open'], data['High'], data['Low'],
data['Close'])
if (check.tail(1).item() != 0):
if (check.tail(1).item() > 0):
dict[
'Pattern'] = colorText.BOLD + colorText.GREEN + '3 Outside Up' + colorText.END
saveDict['Pattern'] = '3 Inside Up'
else:
dict[
'Pattern'] = colorText.BOLD + colorText.FAIL + '3 Outside Down' + colorText.END
saveDict['Pattern'] = '3 Inside Down'
return True
check = talib.CDL3OUTSIDE(data['Open'], data['High'], data['Low'],
data['Close'])
if (check.tail(1).item() != 0):
if (check.tail(1).item() > 0):
dict[
'Pattern'] = colorText.BOLD + colorText.GREEN + '3 Outside Up' + colorText.END
saveDict['Pattern'] = '3 Outside Up'
else:
dict[
'Pattern'] = colorText.BOLD + colorText.FAIL + '3 Outside Down' + colorText.END
saveDict['Pattern'] = '3 Outside Down'
return True
check = talib.CDL3WHITESOLDIERS(data['Open'], data['High'],
data['Low'], data['Close'])
if (check.tail(1).item() != 0):
dict[
'Pattern'] = colorText.BOLD + colorText.GREEN + '3 White Soldiers' + colorText.END
saveDict['Pattern'] = '3 White Soldiers'
return True
check = talib.CDLHARAMI(data['Open'], data['High'], data['Low'],
data['Close'])
if (check.tail(1).item() != 0):
if (check.tail(1).item() > 0):
dict[
'Pattern'] = colorText.BOLD + colorText.GREEN + 'Bullish Harami' + colorText.END
saveDict['Pattern'] = 'Bullish Harami'
else:
dict[
'Pattern'] = colorText.BOLD + colorText.FAIL + 'Bearish Harami' + colorText.END
saveDict['Pattern'] = 'Bearish Harami'
return True
check = talib.CDLHARAMICROSS(data['Open'], data['High'], data['Low'],
data['Close'])
if (check.tail(1).item() != 0):
if (check.tail(1).item() > 0):
dict[
'Pattern'] = colorText.BOLD + colorText.GREEN + 'Bullish Harami Cross' + colorText.END
saveDict['Pattern'] = 'Bullish Harami Cross'
else:
dict[
'Pattern'] = colorText.BOLD + colorText.FAIL + 'Bearish Harami Cross' + colorText.END
saveDict['Pattern'] = 'Bearish Harami Cross'
return True
check = talib.CDLMARUBOZU(data['Open'], data['High'], data['Low'],
data['Close'])
if (check.tail(1).item() != 0):
if (check.tail(1).item() > 0):
dict[
'Pattern'] = colorText.BOLD + colorText.GREEN + 'Bullish Marubozu' + colorText.END
saveDict['Pattern'] = 'Bullish Marubozu'
else:
dict[
'Pattern'] = colorText.BOLD + colorText.FAIL + 'Bearish Marubozu' + colorText.END
saveDict['Pattern'] = 'Bearish Marubozu'
return True
check = talib.CDLHANGINGMAN(data['Open'], data['High'], data['Low'],
data['Close'])
if (check.tail(1).item() != 0):
dict[
'Pattern'] = colorText.BOLD + colorText.FAIL + 'Hanging Man' + colorText.END
saveDict['Pattern'] = 'Hanging Man'
return True
check = talib.CDLHAMMER(data['Open'], data['High'], data['Low'],
data['Close'])
if (check.tail(1).item() != 0):
dict[
'Pattern'] = colorText.BOLD + colorText.GREEN + 'Hammer' + colorText.END
saveDict['Pattern'] = 'Hammer'
return True
check = talib.CDLINVERTEDHAMMER(data['Open'], data['High'],
data['Low'], data['Close'])
if (check.tail(1).item() != 0):
dict[
'Pattern'] = colorText.BOLD + colorText.GREEN + 'Inverted Hammer' + colorText.END
saveDict['Pattern'] = 'Inverted Hammer'
return True
check = talib.CDLSHOOTINGSTAR(data['Open'], data['High'], data['Low'],
data['Close'])
if (check.tail(1).item() != 0):
dict[
'Pattern'] = colorText.BOLD + colorText.FAIL + 'Shooting Star' + colorText.END
saveDict['Pattern'] = 'Shooting Star'
return True
check = talib.CDLDRAGONFLYDOJI(data['Open'], data['High'], data['Low'],
data['Close'])
if (check.tail(1).item() != 0):
dict[
'Pattern'] = colorText.BOLD + colorText.GREEN + 'Dragonfly Doji' + colorText.END
saveDict['Pattern'] = 'Dragonfly Doji'
return True
check = talib.CDLGRAVESTONEDOJI(data['Open'], data['High'],
data['Low'], data['Close'])
if (check.tail(1).item() != 0):
dict[
'Pattern'] = colorText.BOLD + colorText.FAIL + 'Gravestone Doji' + colorText.END
saveDict['Pattern'] = 'Gravestone Doji'
return True
check = talib.CDLDOJI(data['Open'], data['High'], data['Low'],
data['Close'])
if (check.tail(1).item() != 0):
dict['Pattern'] = colorText.BOLD + 'Doji' + colorText.END
saveDict['Pattern'] = 'Doji'
return True
check = talib.CDLENGULFING(data['Open'], data['High'], data['Low'],
data['Close'])
if (check.tail(1).item() != 0):
if (check.tail(1).item() > 0):
dict[
'Pattern'] = colorText.BOLD + colorText.GREEN + 'Bullish Engulfing' + colorText.END
saveDict['Pattern'] = 'Bullish Engulfing'
else:
dict[
'Pattern'] = colorText.BOLD + colorText.FAIL + 'Bearish Engulfing' + colorText.END
saveDict['Pattern'] = 'Bearish Engulfing'
return True
dict['Pattern'] = ''
saveDict['Pattern'] = ''
return False
def _extract_feature(candle, params):
o = candle.open
h = candle.high
l = candle.low
c = candle.close
v = candle.volume
# OHLCV
features = pd.DataFrame()
features['open'] = o
features['high'] = h
features['low'] = l
features['close'] = c
features['volume'] = v
# RSI
features['rsi_s'] = ta.RSI(c, timeperiod=params['rsi_timeperiod_s'])
features['rsi_m'] = ta.RSI(c, timeperiod=params['rsi_timeperiod_m'])
features['rsi_l'] = ta.RSI(c, timeperiod=params['rsi_timeperiod_l'])
# STOCHF
fastk, fastd = ta.STOCHF(h,
l,
c,
fastk_period=params['stockf_fastk_period_s'],
fastd_period=params['stockf_fastd_period_s'],
fastd_matype=ta.MA_Type.T3)
change_stockf = calc_change(fastk, fastd)
change_stockf.index = fastk.index
features['fastk_s'] = fastk
features['fastd_s'] = fastd
features['fast_change_s'] = change_stockf
fastk, fastd = ta.STOCHF(h,
l,
c,
fastk_period=params['stockf_fastk_period_m'],
fastd_period=params['stockf_fastd_period_m'],
fastd_matype=ta.MA_Type.T3)
change_stockf = calc_change(fastk, fastd)
change_stockf.index = fastk.index
features['fastk_m'] = fastk
features['fastd_m'] = fastd
features['fast_change_m'] = change_stockf
fastk, fastd = ta.STOCHF(h,
l,
c,
fastk_period=params['stockf_fastk_period_l'],
fastd_period=params['stockf_fastd_period_l'],
fastd_matype=ta.MA_Type.T3)
change_stockf = calc_change(fastk, fastd)
change_stockf.index = fastk.index
features['fastk_l'] = fastk
features['fastd_l'] = fastd
features['fast_change_l'] = change_stockf
# WILLR
features['willr_s'] = ta.WILLR(h,
l,
c,
timeperiod=params['willr_timeperiod_s'])
features['willr_m'] = ta.WILLR(h,
l,
c,
timeperiod=params['willr_timeperiod_m'])
features['willr_l'] = ta.WILLR(h,
l,
c,
timeperiod=params['willr_timeperiod_l'])
# MACD
macd, macdsignal, macdhist = ta.MACDEXT(
c,
fastperiod=params['macd_fastperiod_s'],
slowperiod=params['macd_slowperiod_s'],
signalperiod=params['macd_signalperiod_s'],
fastmatype=ta.MA_Type.T3,
slowmatype=ta.MA_Type.T3,
signalmatype=ta.MA_Type.T3)
change_macd = calc_change(macd, macdsignal)
change_macd.index = macd.index
features['macd_s'] = macd
features['macdsignal_s'] = macdsignal
features['macdhist_s'] = macdhist
features['change_macd_s'] = change_macd
macd, macdsignal, macdhist = ta.MACDEXT(
c,
fastperiod=params['macd_fastperiod_m'],
slowperiod=params['macd_slowperiod_m'],
signalperiod=params['macd_signalperiod_m'],
fastmatype=ta.MA_Type.T3,
slowmatype=ta.MA_Type.T3,
signalmatype=ta.MA_Type.T3)
change_macd = calc_change(macd, macdsignal)
change_macd.index = macd.index
features['macd_m'] = macd
features['macdsignal_m'] = macdsignal
features['macdhist_m'] = macdhist
features['change_macd_m'] = change_macd
# ROCP
rocp = ta.ROCP(c, timeperiod=params['rocp_timeperiod_s'])
change_rocp = calc_change(
rocp, pd.Series(np.zeros(len(candle)), index=candle.index))
change_rocp.index = rocp.index
features['rocp_s'] = rocp
features['change_rocp_s'] = change_rocp
rocp = ta.ROCP(c, timeperiod=params['rocp_timeperiod_m'])
change_rocp = calc_change(
rocp, pd.Series(np.zeros(len(candle)), index=candle.index))
change_rocp.index = rocp.index
features['rocp_m'] = rocp
features['change_rocp_m'] = change_rocp
rocp = ta.ROCP(c, timeperiod=params['rocp_timeperiod_l'])
change_rocp = calc_change(
rocp, pd.Series(np.zeros(len(candle)), index=candle.index))
change_rocp.index = rocp.index
features['rocp_l'] = rocp
features['change_rocp_l'] = change_rocp
# ボリンジャーバンド
bb_upper, bb_middle, bb_lower = ta.BBANDS(
c,
timeperiod=params['bbands_timeperiod_s'],
nbdevup=params['bbands_nbdevup_s'],
nbdevdn=params['bbands_nbdevdn_s'],
matype=ta.MA_Type.T3)
bb_trend1 = pd.Series(np.zeros(len(candle)), index=candle.index)
bb_trend1[c > bb_upper] = 1
bb_trend1[c < bb_lower] = -1
bb_trend2 = pd.Series(np.zeros(len(candle)), index=candle.index)
bb_trend2[c > bb_middle] = 1
bb_trend2[c < bb_middle] = -1
features['bb_upper_s'] = bb_upper
features['bb_middle_s'] = bb_middle
features['bb_lower_s'] = bb_lower
features['bb_trend1_s'] = bb_trend1
features['bb_trend2_s'] = bb_trend2
bb_upper, bb_middle, bb_lower = ta.BBANDS(
c,
timeperiod=params['bbands_timeperiod_m'],
nbdevup=params['bbands_nbdevup_m'],
nbdevdn=params['bbands_nbdevdn_m'],
matype=ta.MA_Type.T3)
bb_trend1 = pd.Series(np.zeros(len(candle)), index=candle.index)
bb_trend1[c > bb_upper] = 1
bb_trend1[c < bb_lower] = -1
bb_trend2 = pd.Series(np.zeros(len(candle)), index=candle.index)
bb_trend2[c > bb_middle] = 1
bb_trend2[c < bb_middle] = -1
features['bb_upper_m'] = bb_upper
features['bb_middle_m'] = bb_middle
features['bb_lower_m'] = bb_lower
features['bb_trend1_m'] = bb_trend1
features['bb_trend2_m'] = bb_trend2
bb_upper, bb_middle, bb_lower = ta.BBANDS(
c,
timeperiod=params['bbands_timeperiod_l'],
nbdevup=params['bbands_nbdevup_l'],
nbdevdn=params['bbands_nbdevdn_l'],
matype=ta.MA_Type.T3)
bb_trend1 = pd.Series(np.zeros(len(candle)), index=candle.index)
bb_trend1[c > bb_upper] = 1
bb_trend1[c < bb_lower] = -1
bb_trend2 = pd.Series(np.zeros(len(candle)), index=candle.index)
bb_trend2[c > bb_middle] = 1
bb_trend2[c < bb_middle] = -1
features['bb_upper_l'] = bb_upper
features['bb_middle_l'] = bb_middle
features['bb_lower_l'] = bb_lower
features['bb_trend1_l'] = bb_trend1
features['bb_trend2_l'] = bb_trend2
# 出来高
features['obv'] = ta.OBV(c, v)
features['ad'] = ta.AD(h, l, c, v)
features['adosc_s'] = ta.ADOSC(h,
l,
c,
v,
fastperiod=params['fastperiod_adosc_s'],
slowperiod=params['slowperiod_adosc_s'])
# ローソク足
features['CDL2CROWS'] = ta.CDL2CROWS(o, h, l, c)
features['CDL3BLACKCROWS'] = ta.CDL3BLACKCROWS(o, h, l, c)
features['CDL3INSIDE'] = ta.CDL3INSIDE(o, h, l, c)
features['CDL3LINESTRIKE'] = ta.CDL3LINESTRIKE(o, h, l, c)
features['CDL3OUTSIDE'] = ta.CDL3OUTSIDE(o, h, l, c)
features['CDL3STARSINSOUTH'] = ta.CDL3STARSINSOUTH(o, h, l, c)
features['CDL3WHITESOLDIERS'] = ta.CDL3WHITESOLDIERS(o, h, l, c)
features['CDLABANDONEDBABY'] = ta.CDLABANDONEDBABY(o,
h,
l,
c,
penetration=0)
features['CDLADVANCEBLOCK'] = ta.CDLADVANCEBLOCK(o, h, l, c)
features['CDLBELTHOLD'] = ta.CDLBELTHOLD(o, h, l, c)
features['CDLBREAKAWAY'] = ta.CDLBREAKAWAY(o, h, l, c)
features['CDLCLOSINGMARUBOZU'] = ta.CDLCLOSINGMARUBOZU(o, h, l, c)
features['CDLCONCEALBABYSWALL'] = ta.CDLCONCEALBABYSWALL(o, h, l, c)
features['CDLCOUNTERATTACK'] = ta.CDLCOUNTERATTACK(o, h, l, c)
features['CDLDARKCLOUDCOVER'] = ta.CDLDARKCLOUDCOVER(o,
h,
l,
c,
penetration=0)
features['CDLDOJI'] = ta.CDLDOJI(o, h, l, c)
features['CDLDOJISTAR'] = ta.CDLDOJISTAR(o, h, l, c)
features['CDLDRAGONFLYDOJI'] = ta.CDLDRAGONFLYDOJI(o, h, l, c)
features['CDLENGULFING'] = ta.CDLENGULFING(o, h, l, c)
features['CDLEVENINGDOJISTAR'] = ta.CDLEVENINGDOJISTAR(o,
h,
l,
c,
penetration=0)
features['CDLEVENINGSTAR'] = ta.CDLEVENINGSTAR(o, h, l, c, penetration=0)
features['CDLGAPSIDESIDEWHITE'] = ta.CDLGAPSIDESIDEWHITE(o, h, l, c)
features['CDLGRAVESTONEDOJI'] = ta.CDLGRAVESTONEDOJI(o, h, l, c)
features['CDLHAMMER'] = ta.CDLHAMMER(o, h, l, c)
features['CDLHANGINGMAN'] = ta.CDLHANGINGMAN(o, h, l, c)
features['CDLHARAMI'] = ta.CDLHARAMI(o, h, l, c)
features['CDLHARAMICROSS'] = ta.CDLHARAMICROSS(o, h, l, c)
features['CDLHIGHWAVE'] = ta.CDLHIGHWAVE(o, h, l, c)
features['CDLHIKKAKE'] = ta.CDLHIKKAKE(o, h, l, c)
features['CDLHIKKAKEMOD'] = ta.CDLHIKKAKEMOD(o, h, l, c)
features['CDLHOMINGPIGEON'] = ta.CDLHOMINGPIGEON(o, h, l, c)
features['CDLIDENTICAL3CROWS'] = ta.CDLIDENTICAL3CROWS(o, h, l, c)
features['CDLINNECK'] = ta.CDLINNECK(o, h, l, c)
features['CDLINVERTEDHAMMER'] = ta.CDLINVERTEDHAMMER(o, h, l, c)
features['CDLKICKING'] = ta.CDLKICKING(o, h, l, c)
features['CDLKICKINGBYLENGTH'] = ta.CDLKICKINGBYLENGTH(o, h, l, c)
features['CDLLADDERBOTTOM'] = ta.CDLLADDERBOTTOM(o, h, l, c)
features['CDLLONGLEGGEDDOJI'] = ta.CDLLONGLEGGEDDOJI(o, h, l, c)
features['CDLMARUBOZU'] = ta.CDLMARUBOZU(o, h, l, c)
features['CDLMATCHINGLOW'] = ta.CDLMATCHINGLOW(o, h, l, c)
features['CDLMATHOLD'] = ta.CDLMATHOLD(o, h, l, c, penetration=0)
features['CDLMORNINGDOJISTAR'] = ta.CDLMORNINGDOJISTAR(o,
h,
l,
c,
penetration=0)
features['CDLMORNINGSTAR'] = ta.CDLMORNINGSTAR(o, h, l, c, penetration=0)
features['CDLONNECK'] = ta.CDLONNECK(o, h, l, c)
features['CDLPIERCING'] = ta.CDLPIERCING(o, h, l, c)
features['CDLRICKSHAWMAN'] = ta.CDLRICKSHAWMAN(o, h, l, c)
features['CDLRISEFALL3METHODS'] = ta.CDLRISEFALL3METHODS(o, h, l, c)
features['CDLSEPARATINGLINES'] = ta.CDLSEPARATINGLINES(o, h, l, c)
features['CDLSHOOTINGSTAR'] = ta.CDLSHOOTINGSTAR(o, h, l, c)
features['CDLSHORTLINE'] = ta.CDLSHORTLINE(o, h, l, c)
features['CDLSPINNINGTOP'] = ta.CDLSPINNINGTOP(o, h, l, c)
features['CDLSTALLEDPATTERN'] = ta.CDLSTALLEDPATTERN(o, h, l, c)
features['CDLSTICKSANDWICH'] = ta.CDLSTICKSANDWICH(o, h, l, c)
features['CDLTAKURI'] = ta.CDLTAKURI(o, h, l, c)
features['CDLTASUKIGAP'] = ta.CDLTASUKIGAP(o, h, l, c)
features['CDLTHRUSTING'] = ta.CDLTHRUSTING(o, h, l, c)
features['CDLTRISTAR'] = ta.CDLTRISTAR(o, h, l, c)
features['CDLUNIQUE3RIVER'] = ta.CDLUNIQUE3RIVER(o, h, l, c)
features['CDLUPSIDEGAP2CROWS'] = ta.CDLUPSIDEGAP2CROWS(o, h, l, c)
features['CDLXSIDEGAP3METHODS'] = ta.CDLXSIDEGAP3METHODS(o, h, l, c)
window = 5
features_ext = features
for w in range(window):
tmp = features.shift(periods=60 * (w + 1), freq='S')
tmp.columns = [c + '_' + str(w + 1) + 'w' for c in features.columns]
features_ext = pd.concat([features_ext, tmp], axis=1)
return features_ext
def execute(self):
return np.array([
self.open,
self.high,
self.low,
self.close,
self.volume,
talib.HT_DCPERIOD(self.close),
talib.HT_DCPHASE(self.close),
talib.HT_PHASOR(self.close)[0],
talib.HT_PHASOR(self.close)[1],
talib.HT_SINE(self.close)[0],
talib.HT_SINE(self.close)[1],
talib.HT_TRENDMODE(self.close),
talib.ADX(self.high, self.low, self.close),
talib.ADXR(self.high, self.low, self.close),
talib.APO(self.close),
talib.AROON(self.high, self.low)[0],
talib.AROON(self.high, self.low)[1],
talib.AROONOSC(self.high, self.low),
talib.BOP(self.open, self.high, self.low, self.close),
talib.CCI(self.high, self.low, self.close),
talib.CMO(self.close),
talib.DX(self.high, self.low, self.close),
talib.MACD(self.close)[0],
talib.MACD(self.close)[1],
talib.MACD(self.close)[2],
talib.MACDEXT(self.close)[0],
talib.MACDEXT(self.close)[1],
talib.MACDEXT(self.close)[2],
talib.MACDFIX(self.close)[0],
talib.MACDFIX(self.close)[1],
talib.MACDFIX(self.close)[2],
talib.MFI(self.high, self.low, self.close, self.volume),
talib.MINUS_DI(self.high, self.low, self.close),
talib.MINUS_DM(self.high, self.low),
talib.MOM(self.close),
talib.PLUS_DI(self.high, self.low, self.close),
talib.PLUS_DM(self.high, self.low),
talib.PPO(self.close),
talib.ROC(self.close),
talib.ROCP(self.close),
talib.ROCR(self.close),
talib.ROCR100(self.close),
talib.RSI(self.close),
talib.STOCH(self.high, self.low, self.close)[0],
talib.STOCH(self.high, self.low, self.close)[1],
talib.STOCHF(self.high, self.low, self.close)[0],
talib.STOCHF(self.high, self.low, self.close)[1],
talib.STOCHRSI(self.close)[0],
talib.STOCHRSI(self.close)[1],
talib.TRIX(self.close),
talib.ULTOSC(self.high, self.low, self.close),
talib.WILLR(self.high, self.low, self.close),
talib.BBANDS(self.close)[0],
talib.BBANDS(self.close)[1],
talib.BBANDS(self.close)[2],
talib.DEMA(self.close),
talib.EMA(self.close),
talib.HT_TRENDLINE(self.close),
talib.KAMA(self.close),
talib.MA(self.close),
talib.MAMA(self.close)[0],
talib.MAMA(self.close)[1],
talib.MIDPOINT(self.close),
talib.MIDPRICE(self.high, self.low),
talib.SAR(self.high, self.low),
talib.SAREXT(self.high, self.low),
talib.T3(self.close),
talib.TEMA(self.close),
talib.TRIMA(self.close),
talib.WMA(self.close),
talib.AVGPRICE(self.open, self.high, self.low, self.close),
talib.MEDPRICE(self.high, self.low),
talib.TYPPRICE(self.high, self.low, self.close),
talib.WCLPRICE(self.high, self.low, self.close),
talib.ATR(self.high, self.low, self.close),
talib.NATR(self.high, self.low, self.close),
talib.TRANGE(self.high, self.low, self.close),
talib.AD(self.high, self.low, self.close, self.volume),
talib.ADOSC(self.high, self.low, self.close, self.volume),
talib.OBV(self.close, self.volume),
talib.CDL2CROWS(self.open, self.high, self.low, self.close),
talib.CDL3BLACKCROWS(self.open, self.high, self.low, self.close),
talib.CDL3INSIDE(self.open, self.high, self.low, self.close),
talib.CDL3LINESTRIKE(self.open, self.high, self.low, self.close),
talib.CDL3OUTSIDE(self.open, self.high, self.low, self.close),
talib.CDL3STARSINSOUTH(self.open, self.high, self.low, self.close),
talib.CDL3WHITESOLDIERS(self.open, self.high, self.low,
self.close),
talib.CDLABANDONEDBABY(self.open, self.high, self.low, self.close),
talib.CDLADVANCEBLOCK(self.open, self.high, self.low, self.close),
talib.CDLBELTHOLD(self.open, self.high, self.low, self.close),
talib.CDLBREAKAWAY(self.open, self.high, self.low, self.close),
talib.CDLCLOSINGMARUBOZU(self.open, self.high, self.low,
self.close),
talib.CDLCONCEALBABYSWALL(self.open, self.high, self.low,
self.close),
talib.CDLCOUNTERATTACK(self.open, self.high, self.low, self.close),
talib.CDLDARKCLOUDCOVER(self.open, self.high, self.low,
self.close),
talib.CDLDOJI(self.open, self.high, self.low, self.close),
talib.CDLDOJISTAR(self.open, self.high, self.low, self.close),
talib.CDLDRAGONFLYDOJI(self.open, self.high, self.low, self.close),
talib.CDLENGULFING(self.open, self.high, self.low, self.close),
talib.CDLEVENINGDOJISTAR(self.open, self.high, self.low,
self.close),
talib.CDLEVENINGSTAR(self.open, self.high, self.low, self.close),
talib.CDLGAPSIDESIDEWHITE(self.open, self.high, self.low,
self.close),
talib.CDLGRAVESTONEDOJI(self.open, self.high, self.low,
self.close),
talib.CDLHAMMER(self.open, self.high, self.low, self.close),
talib.CDLHANGINGMAN(self.open, self.high, self.low, self.close),
talib.CDLHARAMI(self.open, self.high, self.low, self.close),
talib.CDLHARAMICROSS(self.open, self.high, self.low, self.close),
talib.CDLHIGHWAVE(self.open, self.high, self.low, self.close),
talib.CDLHIKKAKE(self.open, self.high, self.low, self.close),
talib.CDLHIKKAKEMOD(self.open, self.high, self.low, self.close),
talib.CDLHOMINGPIGEON(self.open, self.high, self.low, self.close),
talib.CDLIDENTICAL3CROWS(self.open, self.high, self.low,
self.close),
talib.CDLINNECK(self.open, self.high, self.low, self.close),
talib.CDLINVERTEDHAMMER(self.open, self.high, self.low,
self.close),
talib.CDLKICKING(self.open, self.high, self.low, self.close),
talib.CDLKICKINGBYLENGTH(self.open, self.high, self.low,
self.close),
talib.CDLLADDERBOTTOM(self.open, self.high, self.low, self.close),
talib.CDLLONGLEGGEDDOJI(self.open, self.high, self.low,
self.close),
talib.CDLLONGLINE(self.open, self.high, self.low, self.close),
talib.CDLMARUBOZU(self.open, self.high, self.low, self.close),
talib.CDLMATCHINGLOW(self.open, self.high, self.low, self.close),
talib.CDLMATHOLD(self.open, self.high, self.low, self.close),
talib.CDLMORNINGDOJISTAR(self.open, self.high, self.low,
self.close),
talib.CDLMORNINGSTAR(self.open, self.high, self.low, self.close),
talib.CDLONNECK(self.open, self.high, self.low, self.close),
talib.CDLPIERCING(self.open, self.high, self.low, self.close),
talib.CDLRICKSHAWMAN(self.open, self.high, self.low, self.close),
talib.CDLRISEFALL3METHODS(self.open, self.high, self.low,
self.close),
talib.CDLSEPARATINGLINES(self.open, self.high, self.low,
self.close),
talib.CDLSHOOTINGSTAR(self.open, self.high, self.low, self.close),
talib.CDLSHORTLINE(self.open, self.high, self.low, self.close),
talib.CDLSPINNINGTOP(self.open, self.high, self.low, self.close),
talib.CDLSTALLEDPATTERN(self.open, self.high, self.low,
self.close),
talib.CDLSTICKSANDWICH(self.open, self.high, self.low, self.close),
talib.CDLTAKURI(self.open, self.high, self.low, self.close),
talib.CDLTASUKIGAP(self.open, self.high, self.low, self.close),
talib.CDLTHRUSTING(self.open, self.high, self.low, self.close),
talib.CDLTRISTAR(self.open, self.high, self.low, self.close),
talib.CDLUNIQUE3RIVER(self.open, self.high, self.low, self.close),
talib.CDLUPSIDEGAP2CROWS(self.open, self.high, self.low,
self.close),
talib.CDLXSIDEGAP3METHODS(self.open, self.high, self.low,
self.close),
]).transpose()
def recg_pattern_talib(df_tdata,pattern):
opens = df_tdata['OPEN']
highs = df_tdata['HIGH']
lows = df_tdata['LOW']
closes = df_tdata['CLOSE']
if pattern == 'CDL2CROWS':
pt = talib.CDL2CROWS(opens,highs,lows,closes)
if pattern == 'CDL3BLACKCROWS':
pt = talib.CDL3BLACKCROWS(opens,highs,lows,closes)
if pattern == 'CDL3INSIDE':
pt = talib.CDL3INSIDE(opens,highs,lows,closes)
if pattern == 'CDL3LINESTRIKE':
pt = talib.CDL3LINESTRIKE(opens,highs,lows,closes)
if pattern == 'CDL3OUTSIDE':
pt = talib.CDL3OUTSIDE(opens,highs,lows,closes)
if pattern == 'CDL3STARSINSOUTH':
pt = talib.CDL3STARSINSOUTH(opens,highs,lows,closes)
if pattern == 'CDL3WHITESOLDIERS':
pt = talib.CDL3WHITESOLDIERS(opens,highs,lows,closes)
if pattern == 'CDLABANDONEDBABY':
pt = talib.CDLABANDONEDBABY(opens,highs,lows,closes)
if pattern == 'CDLADVANCEBLOCK':
pt = talib.CDLADVANCEBLOCK(opens,highs,lows,closes)
if pattern == 'CDLBELTHOLD':
pt = talib.CDLBELTHOLD(opens,highs,lows,closes)
if pattern == 'CDLBREAKAWAY':
pt = talib.CDLBREAKAWAY(opens,highs,lows,closes)
if pattern == 'CDLCLOSINGMARUBOZU':
pt = talib.CDLCLOSINGMARUBOZU(opens,highs,lows,closes)
if pattern == 'CDLCONCEALBABYSWALL':
pt = talib.CDLCONCEALBABYSWALL(opens,highs,lows,closes)
if pattern == 'CDLCOUNTERATTACK':
pt = talib.CDLCOUNTERATTACK(opens,highs,lows,closes)
if pattern == 'CDLDARKCLOUDCOVER':
pt = talib.CDLDARKCLOUDCOVER(opens,highs,lows,closes)
if pattern == 'CDLDOJI':
pt = talib.CDLDOJI(opens,highs,lows,closes)
if pattern == 'CDLDOJISTAR':
pt = talib.CDLDOJISTAR(opens,highs,lows,closes)
if pattern == 'CDLDRAGONFLYDOJI':
pt = talib.CDLDRAGONFLYDOJI(opens,highs,lows,closes)
if pattern == 'CDLENGULFING':
pt = talib.CDLENGULFING(opens,highs,lows,closes)
if pattern == 'CDLEVENINGDOJISTAR':
pt = talib.CDLEVENINGDOJISTAR(opens,highs,lows,closes)
if pattern == 'CDLEVENINGSTAR':
pt = talib.CDLEVENINGSTAR(opens,highs,lows,closes)
if pattern == 'CDLGAPSIDESIDEWHITE':
pt = talib.CDLGAPSIDESIDEWHITE(opens,highs,lows,closes)
if pattern == 'CDLGRAVESTONEDOJI':
pt = talib.CDLGRAVESTONEDOJI(opens,highs,lows,closes)
if pattern == 'CDLHAMMER':
pt = talib.CDLHAMMER(opens,highs,lows,closes)
if pattern == 'CDLHANGINGMAN':
pt = talib.CDLHANGINGMAN(opens,highs,lows,closes)
if pattern == 'CDLHARAMI':
pt = talib.CDLHARAMI(opens,highs,lows,closes)
if pattern == 'CDLHARAMICROSS':
pt = talib.CDLHARAMICROSS(opens,highs,lows,closes)
if pattern == 'CDLHIGHWAVE':
pt = talib.CDLHIGHWAVE(opens,highs,lows,closes)
if pattern == 'CDLHIKKAKE':
pt = talib.CDLHIKKAKE(opens,highs,lows,closes)
if pattern == 'CDLHIKKAKEMOD':
pt = talib.CDLHIKKAKEMOD(opens,highs,lows,closes)
if pattern == 'CDLHOMINGPIGEON':
pt = talib.CDLHOMINGPIGEON(opens,highs,lows,closes)
if pattern == 'CDLIDENTICAL3CROWS':
pt = talib.CDLIDENTICAL3CROWS(opens,highs,lows,closes)
if pattern == 'CDLINNECK':
pt = talib.CDLINNECK(opens,highs,lows,closes)
if pattern == 'CDLINVERTEDHAMMER':
pt = talib.CDLINVERTEDHAMMER(opens,highs,lows,closes)
if pattern == 'CDLKICKING':
pt = talib.CDLKICKING(opens,highs,lows,closes)
if pattern == 'CDLKICKINGBYLENGTH':
pt = talib.CDLKICKINGBYLENGTH(opens,highs,lows,closes)
if pattern == 'CDLLADDERBOTTOM':
pt = talib.CDLLADDERBOTTOM(opens,highs,lows,closes)
if pattern == 'CDLLONGLEGGEDDOJI':
pt = talib.CDLLONGLEGGEDDOJI(opens,highs,lows,closes)
if pattern == 'CDLLONGLINE':
pt = talib.CDLLONGLINE(opens,highs,lows,closes)
if pattern == 'CDLMARUBOZU':
pt = talib.CDLMARUBOZU(opens,highs,lows,closes)
if pattern == 'CDLMATCHINGLOW':
pt = talib.CDLMATCHINGLOW(opens,highs,lows,closes)
if pattern == 'CDLMATHOLD':
pt = talib.CDLMATHOLD(opens,highs,lows,closes)
if pattern == 'CDLMORNINGDOJISTAR':
pt = talib.CDLMORNINGDOJISTAR(opens,highs,lows,closes)
if pattern == 'CDLMORNINGSTAR':
pt = talib.CDLMORNINGSTAR(opens,highs,lows,closes)
if pattern == 'CDLONNECK':
pt = talib.CDLONNECK(opens,highs,lows,closes)
if pattern == 'CDLPIERCING':
pt = talib.CDLPIERCING(opens,highs,lows,closes)
if pattern == 'CDLRICKSHAWMAN':
pt = talib.CDLRICKSHAWMAN(opens,highs,lows,closes)
if pattern == 'CDLRISEFALL3METHODS':
pt = talib.CDLRISEFALL3METHODS(opens,highs,lows,closes)
if pattern == 'CDLSEPARATINGLINES':
pt = talib.CDLSEPARATINGLINES(opens,highs,lows,closes)
if pattern == 'CDLSHOOTINGSTAR':
pt = talib.CDLSHOOTINGSTAR(opens,highs,lows,closes)
if pattern == 'CDLSHORTLINE':
pt = talib.CDLSHORTLINE(opens,highs,lows,closes)
if pattern == 'CDLSPINNINGTOP':
pt = talib.CDLSPINNINGTOP(opens,highs,lows,closes)
if pattern == 'CDLSTALLEDPATTERN':
pt = talib.CDLSTALLEDPATTERN(opens,highs,lows,closes)
if pattern == 'CDLSTICKSANDWICH':
pt = talib.CDLSTICKSANDWICH(opens,highs,lows,closes)
if pattern == 'CDLTAKURI':
pt = talib.CDLTAKURI(opens,highs,lows,closes)
if pattern == 'CDLTASUKIGAP':
pt = talib.CDLTASUKIGAP(opens,highs,lows,closes)
if pattern == 'CDLTHRUSTING':
pt = talib.CDLTHRUSTING(opens,highs,lows,closes)
if pattern == 'CDLTRISTAR':
pt = talib.CDLTRISTAR(opens,highs,lows,closes)
if pattern == 'CDLUNIQUE3RIVER':
pt = talib.CDLUNIQUE3RIVER(opens,highs,lows,closes)
if pattern == 'CDLUPSIDEGAP2CROWS':
pt = talib.CDLUPSIDEGAP2CROWS(opens,highs,lows,closes)
if pattern == 'CDLXSIDEGAP3METHODS':
pt = talib.CDLXSIDEGAP3METHODS(opens,highs,lows,closes)
return pt
def all_candles(self):
bullish = [] #uptrending market
bearish = [] #down trending markets
fill = 0
candles = [
{
'candle':
'two_crows',
'count': (talib.CDL2CROWS(self.open, self.high, self.low,
self.close)),
'percent':
-54
},
{
'candle':
'three_blk_crows',
'count': (talib.CDL3BLACKCROWS(self.open, self.high, self.low,
self.close)),
'percent':
-78
},
{
'candle':
'three_inside_up',
'count': (talib.CDL3INSIDE(self.open, self.high, self.low,
self.close)),
'percent':
65
},
#fpound both bullish: 84 bearish: 65
{
'candle':
'three_line_strike',
'count': (talib.CDL3LINESTRIKE(self.open, self.high, self.low,
self.close)),
'percent':
fill
},
{
'candle':
'three_outside_up',
'count': (talib.CDL3OUTSIDE(self.open, self.high, self.low,
self.close)),
'percent':
75
},
{
'candle':
'three_starts_in_the_south',
'count': (talib.CDL3STARSINSOUTH(self.open, self.high,
self.low, self.close)),
'percent':
86
},
{
'candle':
'three_white_soldiers',
'count': (talib.CDL3WHITESOLDIERS(self.open, self.high,
self.low, self.close)),
'percent':
82
},
#found in both bearish = 69 bullish = 70
{
'candle':
'abandoned_baby',
'count': (talib.CDLABANDONEDBABY(self.open, self.high,
self.low, self.close)),
'percent':
fill
},
{
'candle':
'advanced_block',
'count': (talib.CDLADVANCEBLOCK(self.open, self.high, self.low,
self.close)),
'percent':
64
},
#found in both bearish = 68 bullish = 71
{
'candle':
'belt_hold',
'count': (talib.CDLBELTHOLD(self.open, self.high, self.low,
self.close)),
'percent':
fill
},
#found in both bearish = 63 bullish = 59
{
'candle':
'breakaway',
'count': (talib.CDLBREAKAWAY(self.open, self.high, self.low,
self.close)),
'percent':
fill
},
#too close to tell, RIP
{
'candle':
'closing_marubozu',
'count': (talib.CDLCLOSINGMARUBOZU(self.open, self.high,
self.low, self.close)),
'percent':
fill
},
{
'candle':
'concealing_baby_swallow',
'count': (talib.CDLCONCEALBABYSWALL(self.open, self.high,
self.low, self.close)),
'percent':
-75
},
#can't find number
{
'candle':
'counterattack',
'count': (talib.CDLCOUNTERATTACK(self.open, self.high,
self.low, self.close)),
'percent':
fill
},
{
'candle':
'dark_cloud_cover',
'count': (talib.CDLDARKCLOUDCOVER(self.open,
self.high,
self.low,
self.close,
penetration=0)),
'percent':
-60
},
#too many to be sure
{
'candle':
'doji',
'count': (talib.CDLDOJI(self.open, self.high, self.low,
self.close)),
'percent':
fill
},
#too many to be sure
{
'candle':
'doji_star',
'count': (talib.CDLDOJISTAR(self.open, self.high, self.low,
self.close)),
'percent':
fill
},
#indecision
{
'candle':
'dragonfly_doji',
'count': (talib.CDLDRAGONFLYDOJI(self.open, self.high,
self.low, self.close)),
'percent':
fill
},
#found in both bearish = 79 bullish = 63
{
'candle':
'engulfing_pattern',
'count': (talib.CDLENGULFING(self.open, self.high, self.low,
self.close)),
'percent':
fill
},
{
'candle':
'evening_doji_star',
'count': (talib.CDLEVENINGDOJISTAR(self.open,
self.high,
self.low,
self.close,
penetration=0)),
'percent':
-71
},
{
'candle':
'evening_star',
'count': (talib.CDLEVENINGSTAR(self.open,
self.high,
self.low,
self.close,
penetration=0)),
'trend':
'bear',
'percent':
-72
},
#cannot find
{
'candle':
'gap_side_by_side',
'count': (talib.CDLGAPSIDESIDEWHITE(self.open, self.high,
self.low, self.close)),
'percent':
fill
},
#indecision
{
'candle':
'gravestone_doji',
'count': (talib.CDLGRAVESTONEDOJI(self.open, self.high,
self.low, self.close)),
'percent':
fill
},
{
'candle':
'hammer',
'count': (talib.CDLHAMMER(self.open, self.high, self.low,
self.close)),
'percent':
60
},
{
'candle':
'hangning_man',
'count': (talib.CDLHANGINGMAN(self.open, self.high, self.low,
self.close)),
'percent':
59
},
{
'candle':
'harami_pattern',
'count': (talib.CDLHARAMI(self.open, self.high, self.low,
self.close)),
'percent':
53
},
#found in both bearish = 55 bullish = 57
{
'candle':
'harami_cross_pattern',
'count': (talib.CDLHIGHWAVE(self.open, self.high, self.low,
self.close)),
'percent':
fill
},
#indecision
{
'candle':
'high_wave_candle',
'count': (talib.CDLHIGHWAVE(self.open, self.high, self.low,
self.close)),
'percent':
fill
},
#cannot find, i guess
{
'candle':
'hikkake_pattern',
'count': (talib.CDLHIKKAKE(self.open, self.high, self.low,
self.close)),
'percent':
fill
},
#cannot find, i guess
{
'candle':
'modified_hikkake_pattern',
'count': (talib.CDLHIKKAKEMOD(self.open, self.high, self.low,
self.close)),
'percent':
fill
},
{
'candle':
'homing_pigeon',
'count': (talib.CDLHOMINGPIGEON(self.open, self.high, self.low,
self.close)),
'percent':
-56
},
{
'candle':
'indentical_three_crows',
'count': (talib.CDLIDENTICAL3CROWS(self.open, self.high,
self.low, self.close)),
'percent':
-79
},
{
'candle':
'in_neck_pattern',
'count': (talib.CDLINNECK(self.open, self.high, self.low,
self.close)),
'percent':
-53
},
{
'candle':
'inverted_hammer',
'count': (talib.CDLINVERTEDHAMMER(self.open, self.high,
self.low, self.close)),
'percent':
-65
},
#found in both bearish = 54 bullish = 53
{
'candle':
'kicking',
'count': (talib.CDLKICKING(self.open, self.high, self.low,
self.close)),
'percent':
fill
},
#cannot find, i guess
{
'candle':
'kicking_by_longer',
'count': (talib.CDLKICKINGBYLENGTH(self.open, self.high,
self.low, self.close)),
'percent':
fill
},
{
'candle':
'ladder_bottom',
'count': (talib.CDLLADDERBOTTOM(self.open, self.high, self.low,
self.close)),
'percent':
56
},
{
'candle':
'long_legged_doji',
'count': (talib.CDLLONGLEGGEDDOJI(self.open, self.high,
self.low, self.close)),
'percent':
51
},
#cannot find, i guess
{
'candle':
'long_line_candle',
'count': (talib.CDLLONGLINE(self.open, self.high, self.low,
self.close)),
'percent':
fill
},
#too many to be sure
{
'candle':
'marubozu',
'count': (talib.CDLMARUBOZU(self.open, self.high, self.low,
self.close)),
'percent':
fill
},
{
'candle':
'matching_low',
'count': (talib.CDLMATCHINGLOW(self.open, self.high, self.low,
self.close)),
'percent':
-61
},
{
'candle':
'mat_hold',
'count': (talib.CDLMATHOLD(self.open,
self.high,
self.low,
self.close,
penetration=0)),
'percent':
78
},
{
'candle':
'morning_doji_star',
'count': (talib.CDLMORNINGDOJISTAR(self.open,
self.high,
self.low,
self.close,
penetration=0)),
'percent':
fill
},
{
'candle':
'morning_star',
'count': (talib.CDLMORNINGSTAR(self.open,
self.high,
self.low,
self.close,
penetration=0)),
'percent':
76
},
{
'candle':
'on_neck_pattern',
'count': (talib.CDLONNECK(self.open, self.high, self.low,
self.close)),
'percent':
-56
},
{
'candle':
'piercing_pattern',
'count': (talib.CDLPIERCING(self.open, self.high, self.low,
self.close)),
'percent':
64
},
#indecision
{
'candle':
'rickshaw_man',
'count': (talib.CDLRICKSHAWMAN(self.open, self.high, self.low,
self.close)),
'percent':
fill
},
{
'candle':
'rise_fall_three_method',
'count': (talib.CDLRISEFALL3METHODS(self.open, self.high,
self.low, self.close)),
'percent':
74
},
#found in both bearish = 63 bullish = 72
{
'candle':
'separating_lines',
'count': (talib.CDLSEPARATINGLINES(self.open, self.high,
self.low, self.close)),
'percent':
fill
},
#too many to be sure
{
'candle':
'shooting_star',
'count': (talib.CDLSHOOTINGSTAR(self.open, self.high, self.low,
self.close)),
'percent':
fill
},
#indecision
{
'candle':
'short_line_candle',
'count': (talib.CDLSHORTLINE(self.open, self.high, self.low,
self.close)),
'percent':
fill
},
#indecision
{
'candle':
'spinning_top',
'count': (talib.CDLSPINNINGTOP(self.open, self.high, self.low,
self.close)),
'percent':
fill
},
#cannot find, i guess
{
'candle':
'stalled_pattern',
'count': (talib.CDLSTALLEDPATTERN(self.open, self.high,
self.low, self.close)),
'percent':
fill
},
{
'candle':
'stick_sandwich',
'count': (talib.CDLSTICKSANDWICH(self.open, self.high,
self.low, self.close)),
'percent':
-62
},
{
'candle':
'takuri',
'count': (talib.CDLTAKURI(self.open, self.high, self.low,
self.close)),
'percent':
66
},
{
'candle':
'tasuki_gap',
'count': (talib.CDLTASUKIGAP(self.open, self.high, self.low,
self.close)),
'percent':
54
},
{
'candle':
'thrusting_pattern',
'count': (talib.CDLTHRUSTING(self.open, self.high, self.low,
self.close)),
'percent':
57
},
#found in both bearish = 52 bullish = 60
{
'candle':
'tristar',
'count': (talib.CDLTRISTAR(self.open, self.high, self.low,
self.close)),
'percent':
fill
},
{
'candle':
'unique_three_river',
'count': (talib.CDLUNIQUE3RIVER(self.open, self.high, self.low,
self.close)),
'percent':
-60
},
{
'candle':
'upside_gap_two_crows',
'count': (talib.CDLUPSIDEGAP2CROWS(self.open, self.high,
self.low, self.close)),
'percent':
60
},
#found in both bearish = 59 bullish = 62
{
'candle':
'gap_three_methods',
'count': (talib.CDLXSIDEGAP3METHODS(self.open, self.high,
self.low, self.close)),
'percent':
fill
}
]
i = 0
candle_exists = 0
for item in candles:
for i in range(len(item['count'])):
if item['count'][i] > 0:
candle_exists += 1
elif item['count'][i] < 0:
candle_exists -= 1
i = 0
if (candle_exists > 0):
bullish.append({
'name': item['candle'],
'percent': item['percent']
})
if (candle_exists < 0):
bearish.append({
'name': item['candle'],
'percent': item['percent']
})
candle_exists = 0
# bullish_2 = bullish[-1:]
# bearish_2 = bearish[-1:]
return bullish, bearish
def doji(px):
sig = ta.CDLDOJI(px.open, px.high, px.low, px.close)
return sig[-1]
def icic_fut_transform(data):
data.drop_duplicates(subset='date', keep="first", inplace=True)
feature_frame = pd.DataFrame()
feature_frame['Hour'] = data['date'].apply(lambda x: x.hour)
feature_frame['ret1'] = data.close.pct_change()
feature_frame['ret2'] = data.close.pct_change(2)
feature_frame['ret5'] = data.close.pct_change(5)
feature_frame['ret20'] = data.close.pct_change(20)
feature_frame['ret30'] = data.close.pct_change(30)
feature_frame['retl1'] = data.low.pct_change()
feature_frame['retl2'] = data.low.pct_change(2)
feature_frame['retl5'] = data.low.pct_change(5)
feature_frame['reth1'] = data.high.pct_change()
feature_frame['reth2'] = data.high.pct_change(2)
feature_frame['reth5'] = data.high.pct_change(5)
feature_frame['retr5'] = feature_frame.ret1.rolling(5).sum()
feature_frame['retr10'] = feature_frame.ret1.rolling(10).sum()
feature_frame['retr20'] = feature_frame.ret1.rolling(20).sum()
feature_frame['retr40'] = feature_frame.ret1.rolling(40).sum()
# Standard Deviation
feature_frame['std5'] = feature_frame.ret1.rolling(5).std()
feature_frame['std10'] = feature_frame.ret1.rolling(10).std()
feature_frame['std20'] = feature_frame.ret1.rolling(20).std()
feature_frame['std40'] = feature_frame.ret1.rolling(30).std()
feature_frame['vel1'] = (2 * data.close - data.high - data.low)
feature_frame['vel5'] = feature_frame.vel1.rolling(5).sum()
feature_frame['vel10'] = feature_frame.vel1.rolling(10).sum()
feature_frame['vel20'] = feature_frame.vel1.rolling(20).sum()
feature_frame['vel40'] = feature_frame.vel1.rolling(30).sum()
feature_frame['stdv5'] = feature_frame.vel1.rolling(5).std()
feature_frame['stdv10'] = feature_frame.vel1.rolling(10).std()
feature_frame['stdv20'] = feature_frame.vel1.rolling(20).std()
feature_frame['stdv40'] = feature_frame.vel1.rolling(30).std()
feature_frame['stdv5'] = data.volume.rolling(5).std()
feature_frame['stdvv10'] = data.volume.rolling(10).std()
feature_frame['stdvv20'] = data.volume.rolling(20).std()
feature_frame['stdvv40'] = data.volume.rolling(30).std()
# ADDED volume profile and acc, this reduced low vol peformance but increased the high vol performance
feature_frame['vol1'] = data.volume.diff()
feature_frame['vol5'] = data.volume.diff(5)
feature_frame['vol10'] = data.volume.diff(10)
feature_frame['vol20'] = data.volume.diff(20)
feature_frame['vol40'] = data.volume.diff(30)
feature_frame['vols5'] = data.volume.rolling(5).sum()
feature_frame['vols10'] = data.volume.rolling(10).sum()
feature_frame['vols20'] = data.volume.rolling(20).sum()
feature_frame['vols40'] = data.volume.rolling(30).sum()
feature_frame['acc1'] = feature_frame.vel1.diff()
feature_frame['acc5'] = feature_frame.vel1.diff(5)
feature_frame['acc10'] = feature_frame.vel1.diff(10)
feature_frame['acc20'] = feature_frame.vel1.diff(20)
feature_frame['acc40'] = feature_frame.vel1.diff(30)
# Candlestick Patterns
feature_frame['HAMMER'] = ta.CDLHAMMER(data.open, data.high, data.low,
data.close)
feature_frame['DOJI'] = ta.CDLDOJI(data.open, data.high, data.low,
data.close)
feature_frame['SHOOTINGSTAR'] = ta.CDLSHOOTINGSTAR(data.open, data.high,
data.low, data.close)
# changed the timeperiod from 14 to 30
feature_frame['AROONOSC'] = ta.AROONOSC(data.high, data.low, timeperiod=30)
feature_frame['AROONOSC10'] = ta.AROONOSC(data.high,
data.low,
timeperiod=10)
feature_frame['AROONOSC20'] = ta.AROONOSC(data.high,
data.low,
timeperiod=20)
feature_frame['AROONOSC5'] = ta.AROONOSC(data.high, data.low, timeperiod=5)
feature_frame['RSI'] = ta.RSI(data.close, timeperiod=30)
feature_frame['RSI14'] = ta.RSI(data.close, timeperiod=14)
feature_frame['RSI10'] = ta.RSI(data.close, timeperiod=10)
feature_frame['ADXR'] = ta.ADXR(data.high,
data.low,
data.close,
timeperiod=30)
feature_frame['ADXR'] = ta.ADXR(data.high,
data.low,
data.close,
timeperiod=15)
feature_frame['ATR30'] = ta.ATR(data.high,
data.low,
data.close,
timeperiod=30)
feature_frame['ATR'] = ta.ATR(data.high,
data.low,
data.close,
timeperiod=5)
feature_frame['ATR10'] = ta.ATR(data.high,
data.low,
data.close,
timeperiod=10)
feature_frame['ATR20'] = ta.ATR(data.high,
data.low,
data.close,
timeperiod=20)
# Adding jump
feature_frame['Jump'] = data.open - data.close.shift(1)
feature_frame['Jump5'] = data.open - data.close.shift(5)
feature_frame['Jump10'] = data.open - data.close.shift(10)
feature_frame['Jump20'] = data.open - data.close.shift(20)
feature_frame['Jump30'] = data.open - data.close.shift(30)
return feature_frame.dropna()
def Candlesticks_Pattern(data):
data["Upside/Downside Gap Three Methods"] = ta.CDLXSIDEGAP3METHODS(
data["Open"], data["High"], data["Low"], data["Close"])
data["Upside Gap Two Crows"] = ta.CDLUPSIDEGAP2CROWS(
data["Open"], data["High"], data["Low"], data["Close"])
data["Unique 3 River"] = ta.CDLUNIQUE3RIVER(data["Open"], data["High"],
data["Low"], data["Close"])
data["Tristar Pattern"] = ta.CDLTRISTAR(data["Open"], data["High"],
data["Low"], data["Close"])
data["Thrusting Pattern"] = ta.CDLTHRUSTING(data["Open"], data["High"],
data["Low"], data["Close"])
data["Tasuki Gap"] = ta.CDLTASUKIGAP(data["Open"], data["High"],
data["Low"], data["Close"])
data["Takuri (Dragonfly Doji with very long lower shadow)"] = ta.CDLTAKURI(
data["Open"], data["High"], data["Low"], data["Close"])
data["Stick Sandwich"] = ta.CDLSTICKSANDWICH(data["Open"], data["High"],
data["Low"], data["Close"])
data["Stalled Pattern"] = ta.CDLSTALLEDPATTERN(data["Open"], data["High"],
data["Low"], data["Close"])
data["Spinning Top"] = ta.CDLSPINNINGTOP(data["Open"], data["High"],
data["Low"], data["Close"])
data["Short Line Candle"] = ta.CDLSHORTLINE(data["Open"], data["High"],
data["Low"], data["Close"])
data["Shooting Star"] = ta.CDLSHOOTINGSTAR(data["Open"], data["High"],
data["Low"], data["Close"])
data["Separating Lines"] = ta.CDLSEPARATINGLINES(data["Open"],
data["High"], data["Low"],
data["Close"])
data["Rising/Falling Three Methods"] = ta.CDLRISEFALL3METHODS(
data["Open"], data["High"], data["Low"], data["Close"])
data["Rickshaw Man"] = ta.CDLRICKSHAWMAN(data["Open"], data["High"],
data["Low"], data["Close"])
data["Piercing Pattern"] = ta.CDLPIERCING(data["Open"], data["High"],
data["Low"], data["Close"])
data["On-Neck Pattern"] = ta.CDLONNECK(data["Open"], data["High"],
data["Low"], data["Close"])
data["Morning Star"] = ta.CDLMORNINGSTAR(data["Open"], data["High"],
data["Low"], data["Close"])
data["Morning Doji Star"] = ta.CDLMORNINGDOJISTAR(data["Open"],
data["High"],
data["Low"],
data["Close"])
data["Mat Hold"] = ta.CDLMATHOLD(data["Open"], data["High"], data["Low"],
data["Close"])
data["Matching Low"] = ta.CDLMATCHINGLOW(data["Open"], data["High"],
data["Low"], data["Close"])
data["Marubozu"] = ta.CDLMARUBOZU(data["Open"], data["High"], data["Low"],
data["Close"])
data["Long Line Candle"] = ta.CDLLONGLINE(data["Open"], data["High"],
data["Low"], data["Close"])
data["Long Legged Doji"] = ta.CDLLONGLEGGEDDOJI(data["Open"], data["High"],
data["Low"], data["Close"])
data["Ladder Bottom"] = ta.CDLLADDERBOTTOM(data["Open"], data["High"],
data["Low"], data["Close"])
data[
"Kicking - bull/bear determined by the longer marubozu"] = ta.CDLKICKINGBYLENGTH(
data["Open"], data["High"], data["Low"], data["Close"])
data["Kicking"] = ta.CDLKICKING(data["Open"], data["High"], data["Low"],
data["Close"])
data["Inverted Hammer"] = ta.CDLINVERTEDHAMMER(data["Open"], data["High"],
data["Low"], data["Close"])
data["Identical Three Crows"] = ta.CDLIDENTICAL3CROWS(
data["Open"], data["High"], data["Low"], data["Close"])
data["Two Crows"] = ta.CDL2CROWS(data["Open"], data["High"], data["Low"],
data["Close"])
data["Three Black Crows"] = ta.CDL3BLACKCROWS(data["Open"], data["High"],
data["Low"], data["Close"])
data["Three Inside Up/Down"] = ta.CDL3INSIDE(data["Open"], data["High"],
data["Low"], data["Close"])
data["Three-Line Strike"] = ta.CDL3LINESTRIKE(data["Open"], data["High"],
data["Low"], data["Close"])
data["Three Outside Up/Down"] = ta.CDL3OUTSIDE(data["Open"], data["High"],
data["Low"], data["Close"])
data["Three Stars In The South"] = ta.CDL3STARSINSOUTH(
data["Open"], data["High"], data["Low"], data["Close"])
data["Three Advancing White Soldiers"] = ta.CDL3WHITESOLDIERS(
data["Open"], data["High"], data["Low"], data["Close"])
data["Abandoned Baby"] = ta.CDLABANDONEDBABY(data["Open"], data["High"],
data["Low"], data["Close"])
data["Advance Block"] = ta.CDLADVANCEBLOCK(data["Open"], data["High"],
data["Low"], data["Close"])
data["Belt-hold"] = ta.CDLBELTHOLD(data["Open"], data["High"], data["Low"],
data["Close"])
data["Breakaway"] = ta.CDLBREAKAWAY(data["Open"], data["High"],
data["Low"], data["Close"])
data["Closing Marubozu"] = ta.CDLCLOSINGMARUBOZU(data["Open"],
data["High"], data["Low"],
data["Close"])
data["Concealing Baby Swallow"] = ta.CDLCONCEALBABYSWALL(
data["Open"], data["High"], data["Low"], data["Close"])
data["Counterattack"] = ta.CDLCOUNTERATTACK(data["Open"], data["High"],
data["Low"], data["Close"])
data["Dark Cloud Cover"] = ta.CDLDARKCLOUDCOVER(data["Open"], data["High"],
data["Low"], data["Close"])
data["Doji"] = ta.CDLDOJI(data["Open"], data["High"], data["Low"],
data["Close"])
data["Doji Star"] = ta.CDLDOJISTAR(data["Open"], data["High"], data["Low"],
data["Close"])
data["Dragonfly Doji"] = ta.CDLDRAGONFLYDOJI(data["Open"], data["High"],
data["Low"], data["Close"])
data["Engulfing Pattern"] = ta.CDLENGULFING(data["Open"], data["High"],
data["Low"], data["Close"])
data["Evening Doji Star"] = ta.CDLEVENINGDOJISTAR(data["Open"],
data["High"],
data["Low"],
data["Close"])
data["Evening Star"] = ta.CDLEVENINGSTAR(data["Open"], data["High"],
data["Low"], data["Close"])
data["Up/Down-gap side-by-side white lines"] = ta.CDLGAPSIDESIDEWHITE(
data["Open"], data["High"], data["Low"], data["Close"])
data["Gravestone Doji"] = ta.CDLGRAVESTONEDOJI(data["Open"], data["High"],
data["Low"], data["Close"])
data["Hammer"] = ta.CDLHAMMER(data["Open"], data["High"], data["Low"],
data["Close"])
data["Hanging Man"] = ta.CDLHANGINGMAN(data["Open"], data["High"],
data["Low"], data["Close"])
data["Harami Pattern"] = ta.CDLHARAMI(data["Open"], data["High"],
data["Low"], data["Close"])
data["Harami Cross Pattern"] = ta.CDLHARAMICROSS(data["Open"],
data["High"], data["Low"],
data["Close"])
data["High-Wave Candle"] = ta.CDLHIGHWAVE(data["Open"], data["High"],
data["Low"], data["Close"])
data["Hikkake Pattern"] = ta.CDLHIKKAKE(data["Open"], data["High"],
data["Low"], data["Close"])
data["Modified Hikkake Pattern"] = ta.CDLHIKKAKEMOD(
data["Open"], data["High"], data["Low"], data["Close"])
data["Homing Pigeon"] = ta.CDLHOMINGPIGEON(data["Open"], data["High"],
data["Low"], data["Close"])
return (data)
def pattern_recognition(candles: np.ndarray, pattern_type: str, penetration: int = 0, sequential: bool = False) -> \
Union[int, np.ndarray]:
"""
Pattern Recognition
:param candles: np.ndarray
:param penetration: int - default = 0
:param pattern_type: str
:param sequential: bool - default=False
:return: int | np.ndarray
"""
warmup_candles_num = get_config('env.data.warmup_candles_num', 240)
if not sequential and len(candles) > warmup_candles_num:
candles = candles[-warmup_candles_num:]
if pattern_type == "CDL2CROWS":
res = talib.CDL2CROWS(candles[:, 1], candles[:, 3], candles[:, 4], candles[:, 2])
elif pattern_type == "CDL3BLACKCROWS":
res = talib.CDL3BLACKCROWS(candles[:, 1], candles[:, 3], candles[:, 4], candles[:, 2])
elif pattern_type == "CDL3INSIDE":
res = talib.CDL3INSIDE(candles[:, 1], candles[:, 3], candles[:, 4], candles[:, 2])
elif pattern_type == "CDL3LINESTRIKE":
res = talib.CDL3LINESTRIKE(candles[:, 1], candles[:, 3], candles[:, 4], candles[:, 2])
elif pattern_type == "CDL3OUTSIDE":
res = talib.CDL3OUTSIDE(candles[:, 1], candles[:, 3], candles[:, 4], candles[:, 2])
elif pattern_type == "CDL3STARSINSOUTH":
res = talib.CDL3STARSINSOUTH(candles[:, 1], candles[:, 3], candles[:, 4], candles[:, 2])
elif pattern_type == "CDL3WHITESOLDIERS":
res = talib.CDL3WHITESOLDIERS(candles[:, 1], candles[:, 3], candles[:, 4], candles[:, 2])
elif pattern_type == "CDLABANDONEDBABY":
res = talib.CDLABANDONEDBABY(candles[:, 1], candles[:, 3], candles[:, 4], candles[:, 2],
penetration=penetration)
elif pattern_type == "CDLADVANCEBLOCK":
res = talib.CDLADVANCEBLOCK(candles[:, 1], candles[:, 3], candles[:, 4], candles[:, 2])
elif pattern_type == "CDLBELTHOLD":
res = talib.CDLBELTHOLD(candles[:, 1], candles[:, 3], candles[:, 4], candles[:, 2])
elif pattern_type == "CDLBREAKAWAY":
res = talib.CDLBREAKAWAY(candles[:, 1], candles[:, 3], candles[:, 4], candles[:, 2])
elif pattern_type == "CDLCLOSINGMARUBOZU":
res = talib.CDLCLOSINGMARUBOZU(candles[:, 1], candles[:, 3], candles[:, 4], candles[:, 2])
elif pattern_type == "CDLCONCEALBABYSWALL":
res = talib.CDLCONCEALBABYSWALL(candles[:, 1], candles[:, 3], candles[:, 4], candles[:, 2])
elif pattern_type == "CDLCOUNTERATTACK":
res = talib.CDLCOUNTERATTACK(candles[:, 1], candles[:, 3], candles[:, 4], candles[:, 2])
elif pattern_type == "CDLDARKCLOUDCOVER":
res = talib.CDLDARKCLOUDCOVER(candles[:, 1], candles[:, 3], candles[:, 4], candles[:, 2],
penetration=penetration)
elif pattern_type == "CDLDOJI":
res = talib.CDLDOJI(candles[:, 1], candles[:, 3], candles[:, 4], candles[:, 2])
elif pattern_type == "CDLDOJISTAR":
res = talib.CDLDOJISTAR(candles[:, 1], candles[:, 3], candles[:, 4], candles[:, 2])
elif pattern_type == "CDLDRAGONFLYDOJI":
res = talib.CDLDRAGONFLYDOJI(candles[:, 1], candles[:, 3], candles[:, 4], candles[:, 2])
elif pattern_type == "CDLENGULFING":
res = talib.CDLENGULFING(candles[:, 1], candles[:, 3], candles[:, 4], candles[:, 2])
elif pattern_type == "CDLEVENINGDOJISTAR":
res = talib.CDLEVENINGDOJISTAR(candles[:, 1], candles[:, 3], candles[:, 4], candles[:, 2],
penetration=penetration)
elif pattern_type == "CDLEVENINGSTAR":
res = talib.CDLEVENINGSTAR(candles[:, 1], candles[:, 3], candles[:, 4], candles[:, 2], penetration=penetration)
elif pattern_type == "CDLGAPSIDESIDEWHITE":
res = talib.CDLGAPSIDESIDEWHITE(candles[:, 1], candles[:, 3], candles[:, 4], candles[:, 2])
elif pattern_type == "CDLGRAVESTONEDOJI":
res = talib.CDLGRAVESTONEDOJI(candles[:, 1], candles[:, 3], candles[:, 4], candles[:, 2])
elif pattern_type == "CDLHAMMER":
res = talib.CDLHAMMER(candles[:, 1], candles[:, 3], candles[:, 4], candles[:, 2])
elif pattern_type == "CDLHANGINGMAN":
res = talib.CDLHANGINGMAN(candles[:, 1], candles[:, 3], candles[:, 4], candles[:, 2])
elif pattern_type == "CDLHARAMI":
res = talib.CDLHARAMI(candles[:, 1], candles[:, 3], candles[:, 4], candles[:, 2])
elif pattern_type == "CDLHARAMICROSS":
res = talib.CDLHARAMICROSS(candles[:, 1], candles[:, 3], candles[:, 4], candles[:, 2])
elif pattern_type == "CDLHIGHWAVE":
res = talib.CDLHIGHWAVE(candles[:, 1], candles[:, 3], candles[:, 4], candles[:, 2])
elif pattern_type == "CDLHIKKAKE":
res = talib.CDLHIKKAKE(candles[:, 1], candles[:, 3], candles[:, 4], candles[:, 2])
elif pattern_type == "CDLHIKKAKEMOD":
res = talib.CDLHIKKAKEMOD(candles[:, 1], candles[:, 3], candles[:, 4], candles[:, 2])
elif pattern_type == "CDLHOMINGPIGEON":
res = talib.CDLHOMINGPIGEON(candles[:, 1], candles[:, 3], candles[:, 4], candles[:, 2])
elif pattern_type == "CDLIDENTICAL3CROWS":
res = talib.CDLIDENTICAL3CROWS(candles[:, 1], candles[:, 3], candles[:, 4], candles[:, 2])
elif pattern_type == "CDLINNECK":
res = talib.CDLINNECK(candles[:, 1], candles[:, 3], candles[:, 4], candles[:, 2])
elif pattern_type == "CDLINVERTEDHAMMER":
res = talib.CDLINVERTEDHAMMER(candles[:, 1], candles[:, 3], candles[:, 4], candles[:, 2])
elif pattern_type == "CDLKICKING":
res = talib.CDLKICKING(candles[:, 1], candles[:, 3], candles[:, 4], candles[:, 2])
elif pattern_type == "CDLKICKINGBYLENGTH":
res = talib.CDLKICKINGBYLENGTH(candles[:, 1], candles[:, 3], candles[:, 4], candles[:, 2])
elif pattern_type == "CDLLADDERBOTTOM":
res = talib.CDLLADDERBOTTOM(candles[:, 1], candles[:, 3], candles[:, 4], candles[:, 2])
elif pattern_type == "CDLLONGLEGGEDDOJI":
res = talib.CDLLONGLEGGEDDOJI(candles[:, 1], candles[:, 3], candles[:, 4], candles[:, 2])
elif pattern_type == "CDLLONGLINE":
res = talib.CDLLONGLINE(candles[:, 1], candles[:, 3], candles[:, 4], candles[:, 2])
elif pattern_type == "CDLMARUBOZU":
res = talib.CDLMARUBOZU(candles[:, 1], candles[:, 3], candles[:, 4], candles[:, 2])
elif pattern_type == "CDLMATCHINGLOW":
res = talib.CDLMATCHINGLOW(candles[:, 1], candles[:, 3], candles[:, 4], candles[:, 2])
elif pattern_type == "CDLMATHOLD":
res = talib.CDLMATHOLD(candles[:, 1], candles[:, 3], candles[:, 4], candles[:, 2], penetration=penetration)
elif pattern_type == "CDLMORNINGDOJISTAR":
res = talib.CDLMORNINGDOJISTAR(candles[:, 1], candles[:, 3], candles[:, 4], candles[:, 2],
penetration=penetration)
elif pattern_type == "CDLMORNINGSTAR":
res = talib.CDLMORNINGSTAR(candles[:, 1], candles[:, 3], candles[:, 4], candles[:, 2], penetration=penetration)
elif pattern_type == "CDLONNECK":
res = talib.CDLONNECK(candles[:, 1], candles[:, 3], candles[:, 4], candles[:, 2])
elif pattern_type == "CDLPIERCING":
res = talib.CDLPIERCING(candles[:, 1], candles[:, 3], candles[:, 4], candles[:, 2])
elif pattern_type == "CDLRICKSHAWMAN":
res = talib.CDLRICKSHAWMAN(candles[:, 1], candles[:, 3], candles[:, 4], candles[:, 2])
elif pattern_type == "CDLRISEFALL3METHODS":
res = talib.CDLRISEFALL3METHODS(candles[:, 1], candles[:, 3], candles[:, 4], candles[:, 2])
elif pattern_type == "CDLSEPARATINGLINES":
res = talib.CDLSEPARATINGLINES(candles[:, 1], candles[:, 3], candles[:, 4], candles[:, 2])
elif pattern_type == "CDLSHOOTINGSTAR":
res = talib.CDLSHOOTINGSTAR(candles[:, 1], candles[:, 3], candles[:, 4], candles[:, 2])
elif pattern_type == "CDLSHORTLINE":
res = talib.CDLSHORTLINE(candles[:, 1], candles[:, 3], candles[:, 4], candles[:, 2])
elif pattern_type == "CDLSPINNINGTOP":
res = talib.CDLSPINNINGTOP(candles[:, 1], candles[:, 3], candles[:, 4], candles[:, 2])
elif pattern_type == "CDLSTALLEDPATTERN":
res = talib.CDLSTALLEDPATTERN(candles[:, 1], candles[:, 3], candles[:, 4], candles[:, 2])
elif pattern_type == "CDLSTICKSANDWICH":
res = talib.CDLSTICKSANDWICH(candles[:, 1], candles[:, 3], candles[:, 4], candles[:, 2])
elif pattern_type == "CDLTAKURI":
res = talib.CDLTAKURI(candles[:, 1], candles[:, 3], candles[:, 4], candles[:, 2])
elif pattern_type == "CDLTASUKIGAP":
res = talib.CDLTASUKIGAP(candles[:, 1], candles[:, 3], candles[:, 4], candles[:, 2])
elif pattern_type == "CDLTHRUSTING":
res = talib.CDLTHRUSTING(candles[:, 1], candles[:, 3], candles[:, 4], candles[:, 2])
elif pattern_type == "CDLTRISTAR":
res = talib.CDLTRISTAR(candles[:, 1], candles[:, 3], candles[:, 4], candles[:, 2])
elif pattern_type == "CDLUNIQUE3RIVER":
res = talib.CDLUNIQUE3RIVER(candles[:, 1], candles[:, 3], candles[:, 4], candles[:, 2])
elif pattern_type == "CDLUPSIDEGAP2CROWS":
res = talib.CDLUPSIDEGAP2CROWS(candles[:, 1], candles[:, 3], candles[:, 4], candles[:, 2])
elif pattern_type == "CDLXSIDEGAP3METHODS":
res = talib.CDLXSIDEGAP3METHODS(candles[:, 1], candles[:, 3], candles[:, 4], candles[:, 2])
else:
raise ValueError('pattern type string not recognised')
return res / 100 if sequential else res[-1] / 100
def doji(px):
sig = ta.CDLDOJI(px.open.values, px.high.values, px.low.values,
px.close.values)
return sig[-1]
def get_exogenous_data(data, **kwargs):
"""
:param data: DataFrame of underlying market info, should include ['open', 'close', 'low', 'high', 'volumn', 'money'] columns, where 'money' is trading amount.
:param kwargs: parameter for construction of new variables
:return: dict of the addictional varibales
"""
open = data['open']
high = data['high']
low = data['low']
close = data['close']
volume = data['volume']
all_para = kwargs.keys() # may be useful in the future??
indicators_df = pd.DataFrame()
"""
get all the technical indicators, reference: https://mrjbq7.github.io/ta-lib/doc_index.html
"""
"""momentum indicators"""
indicators_df['ADX'] = talib.ADX(
high, low, close, timeperiod=14) # Average Directional Movement Index
indicators_df['ADXR'] = talib.ADXR(
high, low, close,
timeperiod=14) # Average Directional Movement Index Rating
indicators_df['APO'] = talib.APO(close,
fastperiod=12,
slowperiod=26,
matype=0) # Absolute Price Oscillator
indicators_df['aroondown'], indicators_df['aroonup'] = talib.AROON(
high, low, timeperiod=14) # Aroon
indicators_df['AROONOSC'] = talib.AROONOSC(
high, low, timeperiod=14) # Aroon Oscillator
indicators_df['BOP'] = talib.BOP(open, high, low,
close) # Balance Of Power
indicators_df['CCI'] = talib.CCI(high, low, close,
timeperiod=14) # Commodity Channel Index
indicators_df['CMO'] = talib.CMO(
close, timeperiod=14) # Chande Momentum Oscillator
indicators_df['DX'] = talib.DX(high, low, close,
timeperiod=14) # Directional Movement Index
indicators_df['macd1'], indicators_df[
'macdsignal1'], macdhist = talib.MACD(
close, fastperiod=12, slowperiod=26,
signalperiod=9) # Moving Average Convergence/Divergence
indicators_df['macd2'], indicators_df[
'macdsignal2'], macdhist = talib.MACDEXT(
close,
fastperiod=12,
fastmatype=0,
slowperiod=26,
slowmatype=0,
signalperiod=9,
signalmatype=0) # MACD with controllable MA type
indicators_df['macd3'], indicators_df[
'macdsignal3'], macdhist = talib.MACDFIX(
close,
signalperiod=9) # Moving Average Convergence/Divergence Fix 12/26
indicators_df['MFI'] = talib.MFI(high, low, close, volume,
timeperiod=14) # Money Flow Index
indicators_df['MINUS_DI'] = talib.MINUS_DI(
high, low, close, timeperiod=14) # Minus Directional Indicator
indicators_df['MINUS_DM'] = talib.MINUS_DM(
high, low, timeperiod=14) # Minus Directional Movement
indicators_df['MOM'] = talib.MOM(close, timeperiod=10) # Momentum
indicators_df['PLUS_DI'] = talib.PLUS_DI(
high, low, close, timeperiod=14) # Plus Directional Indicator
indicators_df['PLUS_DM'] = talib.PLUS_DM(
high, low, timeperiod=14) # Plus Directional Movement
indicators_df['PPO'] = talib.PPO(close,
fastperiod=12,
slowperiod=26,
matype=0) # Percentage Price Oscillator
indicators_df['ROC'] = talib.ROC(
close, timeperiod=10) # Rate of change : ((price/prevPrice)-1)*100
indicators_df['ROCP'] = talib.ROCP(
close, timeperiod=10
) # Rate of change Percentage: (price-prevPrice)/prevPrice
indicators_df['ROCR'] = talib.ROCR(
close, timeperiod=10) # Rate of change ratio: (price/prevPrice)
indicators_df['ROCR100'] = talib.ROCR100(
close,
timeperiod=10) # Rate of change ratio 100 scale: (price/prevPrice)*100
indicators_df['RSI'] = talib.RSI(close,
timeperiod=14) # Relative Strength Index
indicators_df['slowk'], indicators_df['slowd'] = talib.STOCH(
high,
low,
close,
fastk_period=5,
slowk_period=3,
slowk_matype=0,
slowd_period=3,
slowd_matype=0) # Stochastic
indicators_df['fastk'], indicators_df['fastd'] = talib.STOCHF(
high, low, close, fastk_period=5, fastd_period=3,
fastd_matype=0) # Stochastic Fast
indicators_df['S-RSIk'], indicators_df['S-RSId'] = talib.STOCHRSI(
close, timeperiod=14, fastk_period=5, fastd_period=3,
fastd_matype=0) # Stochastic Relative Strength Index
indicators_df['TRIX'] = talib.TRIX(
close,
timeperiod=30) # 1-day Rate-Of-Change (ROC) of a Triple Smooth EMA
indicators_df['ULTOSC'] = talib.ULTOSC(
high, low, close, timeperiod1=7, timeperiod2=14,
timeperiod3=28) # Ultimate Oscillator
indicators_df['WILLR'] = talib.WILLR(high, low, close,
timeperiod=14) # Williams' %R
"""Volume indicators"""
indicators_df['AD'] = talib.AD(high, low, close,
volume) # Chaikin A/D Line
indicators_df['ADOSC'] = talib.ADOSC(
high, low, close, volume, fastperiod=3,
slowperiod=10) # Chaikin A/D Oscillator
indicators_df['OBV'] = talib.OBV(close, volume) # On Balance Volume
"""Volatility indicators"""
indicators_df['ATR'] = talib.ATR(high, low, close,
timeperiod=14) # Average True Range
indicators_df['NATR'] = talib.NATR(
high, low, close, timeperiod=14) # Normalized Average True Range
indicators_df['TRANGE'] = talib.TRANGE(high, low, close) # True Range
"""Cycle Indicators"""
indicators_df['HT_DCPERIOD'] = talib.HT_DCPERIOD(
close) # Hilbert Transform - Dominant Cycle Period
indicators_df['HT_DCPHASE'] = talib.HT_DCPHASE(
close) # Hilbert Transform - Dominant Cycle Phase
indicators_df['inphase'], indicators_df['quadrature'] = talib.HT_PHASOR(
close) # Hilbert Transform - Phasor Components
indicators_df['sine'], indicators_df['leadsine'] = talib.HT_SINE(
close) # Hilbert Transform - SineWave
indicators_df['HT_TRENDMODE'] = talib.HT_TRENDMODE(
close) # Hilbert Transform - Trend vs Cycle Mode
"""Pattern Recognition"""
indicators_df['CDL2CROWS'] = talib.CDL2CROWS(open, high, low,
close) # Two Crows
indicators_df['CDL3BLACKCROWS'] = talib.CDL3BLACKCROWS(
open, high, low, close) # Three Black Crows
indicators_df['CDL3INSIDE'] = talib.CDL3INSIDE(
open, high, low, close) # Three Inside Up/Down
indicators_df['CDL3LINESTRIKE'] = talib.CDL3LINESTRIKE(
open, high, low, close) # Three-Line Strike
indicators_df['CDL3OUTSIDE'] = talib.CDL3OUTSIDE(
open, high, low, close) # Three Outside Up/Down
indicators_df['CDL3STARSINSOUTH'] = talib.CDL3STARSINSOUTH(
open, high, low, close) # Three Stars In The South
indicators_df['CDL3WHITESOLDIERS'] = talib.CDL3WHITESOLDIERS(
open, high, low, close) # Three Advancing White Soldiers
indicators_df['CDLABANDONEDBABY'] = talib.CDLABANDONEDBABY(
open, high, low, close, penetration=0) # Abandoned Baby
indicators_df['CDLADVANCEBLOCK'] = talib.CDLADVANCEBLOCK(
open, high, low, close) # Advance Block
indicators_df['CDLBELTHOLD'] = talib.CDLBELTHOLD(open, high, low,
close) # Belt-hold
indicators_df['CDLBREAKAWAY'] = talib.CDLBREAKAWAY(open, high, low,
close) # Breakaway
indicators_df['CDLCLOSINGMARUBOZU'] = talib.CDLCLOSINGMARUBOZU(
open, high, low, close) # Closing Marubozu
indicators_df['CDLCONCEALBABYSWALL'] = talib.CDLCONCEALBABYSWALL(
open, high, low, close) # Concealing Baby Swallow
indicators_df['CDLCOUNTERATTACK'] = talib.CDLCOUNTERATTACK(
open, high, low, close) # Counterattack
indicators_df['CDLDARKCLOUDCOVER'] = talib.CDLDARKCLOUDCOVER(
open, high, low, close, penetration=0) # Dark Cloud Cover
indicators_df['CDLDOJI'] = talib.CDLDOJI(open, high, low, close) # Doji
indicators_df['CDLDOJISTAR'] = talib.CDLDOJISTAR(open, high, low,
close) # Doji Star
indicators_df['CDLDRAGONFLYDOJI'] = talib.CDLDRAGONFLYDOJI(
open, high, low, close) # Dragonfly Doji
indicators_df['CDLENGULFING'] = talib.CDLENGULFING(
open, high, low, close) # Engulfing Pattern
indicators_df['CDLEVENINGDOJISTAR'] = talib.CDLEVENINGDOJISTAR(
open, high, low, close, penetration=0) # Evening Doji Star
indicators_df['CDLEVENINGSTAR'] = talib.CDLEVENINGSTAR(
open, high, low, close, penetration=0) # Evening Star
indicators_df['CDLGAPSIDESIDEWHITE'] = talib.CDLGAPSIDESIDEWHITE(
open, high, low, close) # Up/Down-gap side-by-side white lines
indicators_df['CDLGRAVESTONEDOJI'] = talib.CDLGRAVESTONEDOJI(
open, high, low, close) # Gravestone Doji
indicators_df['CDLHAMMER'] = talib.CDLHAMMER(open, high, low,
close) # Hammer
indicators_df['CDLHANGINGMAN'] = talib.CDLHANGINGMAN(
open, high, low, close) # Hanging Man
indicators_df['CDLHARAMI'] = talib.CDLHARAMI(open, high, low,
close) # Harami Pattern
indicators_df['CDLHARAMICROSS'] = talib.CDLHARAMICROSS(
open, high, low, close) # Harami Cross Pattern
indicators_df['CDLHIGHWAVE'] = talib.CDLHIGHWAVE(open, high, low,
close) # High-Wave Candle
indicators_df['CDLHIKKAKE'] = talib.CDLHIKKAKE(open, high, low,
close) # Hikkake Pattern
indicators_df['CDLHIKKAKEMOD'] = talib.CDLHIKKAKEMOD(
open, high, low, close) # Modified Hikkake Pattern
indicators_df['CDLHOMINGPIGEON'] = talib.CDLHOMINGPIGEON(
open, high, low, close) # Homing Pigeon
indicators_df['CDLIDENTICAL3CROWS'] = talib.CDLIDENTICAL3CROWS(
open, high, low, close) # Identical Three Crows
indicators_df['CDLINNECK'] = talib.CDLINNECK(open, high, low,
close) # In-Neck Pattern
indicators_df['CDLINVERTEDHAMMER'] = talib.CDLINVERTEDHAMMER(
open, high, low, close) # Inverted Hammer
indicators_df['CDLKICKING'] = talib.CDLKICKING(open, high, low,
close) # Kicking
indicators_df['CDLKICKINGBYLENGTH'] = talib.CDLKICKINGBYLENGTH(
open, high, low,
close) # Kicking - bull/bear determined by the longer marubozu
indicators_df['CDLLADDERBOTTOM'] = talib.CDLLADDERBOTTOM(
open, high, low, close) # Ladder Bottom
indicators_df['CDLLONGLEGGEDDOJI'] = talib.CDLLONGLEGGEDDOJI(
open, high, low, close) # Long Legged Doji
indicators_df['CDLLONGLINE'] = talib.CDLLONGLINE(open, high, low,
close) # Long Line Candle
indicators_df['CDLMARUBOZU'] = talib.CDLMARUBOZU(open, high, low,
close) # Marubozu
indicators_df['CDLMATCHINGLOW'] = talib.CDLMATCHINGLOW(
open, high, low, close) # Matching Low
indicators_df['CDLMATHOLD'] = talib.CDLMATHOLD(open,
high,
low,
close,
penetration=0) # Mat Hold
indicators_df['CDLMORNINGDOJISTAR'] = talib.CDLMORNINGDOJISTAR(
open, high, low, close, penetration=0) # Morning Doji Star
indicators_df['CDLMORNINGSTAR'] = talib.CDLMORNINGSTAR(
open, high, low, close, penetration=0) # Morning Star
indicators_df['CDLONNECK'] = talib.CDLONNECK(open, high, low,
close) # On-Neck Pattern
indicators_df['CDLPIERCING'] = talib.CDLPIERCING(open, high, low,
close) # Piercing Pattern
indicators_df['CDLRICKSHAWMAN'] = talib.CDLRICKSHAWMAN(
open, high, low, close) # Rickshaw Man
indicators_df['CDLRISEFALL3METHODS'] = talib.CDLRISEFALL3METHODS(
open, high, low, close) # Rising/Falling Three Methods
indicators_df['CDLSEPARATINGLINES'] = talib.CDLSEPARATINGLINES(
open, high, low, close) # Separating Lines
indicators_df['CDLSHOOTINGSTAR'] = talib.CDLSHOOTINGSTAR(
open, high, low, close) # Shooting Star
indicators_df['CDLSHORTLINE'] = talib.CDLSHORTLINE(
open, high, low, close) # Short Line Candle
indicators_df['CDLSPINNINGTOP'] = talib.CDLSPINNINGTOP(
open, high, low, close) # Spinning Top
indicators_df['CDLSTALLEDPATTERN'] = talib.CDLSTALLEDPATTERN(
open, high, low, close) # Stalled Pattern
indicators_df['CDLSTICKSANDWICH'] = talib.CDLSTICKSANDWICH(
open, high, low, close) # Stick Sandwich
indicators_df['CDLTAKURI'] = talib.CDLTAKURI(
open, high, low,
close) # Takuri (Dragonfly Doji with very long lower shadow)
indicators_df['CDLTASUKIGAP'] = talib.CDLTASUKIGAP(open, high, low,
close) # Tasuki Gap
indicators_df['CDLTHRUSTING'] = talib.CDLTHRUSTING(
open, high, low, close) # Thrusting Pattern
indicators_df['CDLTRISTAR'] = talib.CDLTRISTAR(open, high, low,
close) # Tristar Pattern
indicators_df['CDLUNIQUE3RIVER'] = talib.CDLUNIQUE3RIVER(
open, high, low, close) # Unique 3 River
indicators_df['CDLUPSIDEGAP2CROWS'] = talib.CDLUPSIDEGAP2CROWS(
open, high, low, close) # Upside Gap Two Crows
indicators_df['CDLXSIDEGAP3METHODS'] = talib.CDLXSIDEGAP3METHODS(
open, high, low, close) # Upside/Downside Gap Three Methods
return indicators_df
def main():
# read csv file and transform it to datafeed (df):
df = pd.read_csv(current_dir + "/" + base_dir + "/" + in_dir + "/" +
in_dir + '_' + stock_symbol + '.csv')
# set numpy datafeed from df:
df_numpy = {
'Date': np.array(df['date']),
'Open': np.array(df['open'], dtype='float'),
'High': np.array(df['high'], dtype='float'),
'Low': np.array(df['low'], dtype='float'),
'Close': np.array(df['close'], dtype='float'),
'Volume': np.array(df['volume'], dtype='float')
}
date = df_numpy['Date']
openp = df_numpy['Open']
high = df_numpy['High']
low = df_numpy['Low']
close = df_numpy['Close']
volume = df_numpy['Volume']
#########################################
##### Pattern Recognition Functions #####
#########################################
#CDL2CROWS - Two Crows
cdl2crows = ta.CDL2CROWS(openp, high, low, close)
#CDL3BLACKCROWS - Three Black Crows
cdl3blackcrows = ta.CDL3BLACKCROWS(openp, high, low, close)
#CDL3INSIDE - Three Inside Up/Down
cdl3inside = ta.CDL3INSIDE(openp, high, low, close)
#CDL3LINESTRIKE - Three-Line Strike
cdl3linestrike = ta.CDL3LINESTRIKE(openp, high, low, close)
#CDL3OUTSIDE - Three Outside Up/Down
cdl3outside = ta.CDL3OUTSIDE(openp, high, low, close)
#CDL3STARSINSOUTH - Three Stars In The South
cdl3starinsouth = ta.CDL3STARSINSOUTH(openp, high, low, close)
#CDL3WHITESOLDIERS - Three Advancing White Soldiers
cdl3whitesoldiers = ta.CDL3WHITESOLDIERS(openp, high, low, close)
#CDLABANDONEDBABY - Abandoned Baby
cdlabandonbaby = ta.CDLABANDONEDBABY(openp,
high,
low,
close,
penetration=0)
#CDLADVANCEBLOCK - Advance Block
cdladvanceblock = ta.CDLADVANCEBLOCK(openp, high, low, close)
#CDLBELTHOLD - Belt-hold
cdlbelthold = ta.CDLBELTHOLD(openp, high, low, close)
#CDLBREAKAWAY - Breakaway
cdlbreakway = ta.CDLBREAKAWAY(openp, high, low, close)
#CDLCLOSINGMARUBOZU - Closing Marubozu
cdlclosingmarubozu = ta.CDLCLOSINGMARUBOZU(openp, high, low, close)
#CDLCONCEALBABYSWALL - Concealing Baby Swallow
cdlconcealbabyswall = ta.CDLCONCEALBABYSWALL(openp, high, low, close)
#CDLCOUNTERATTACK - Counterattack
cdlcounterattack = ta.CDLCOUNTERATTACK(openp, high, low, close)
#CDLDARKCLOUDCOVER - Dark Cloud Cover
cdldarkcloudcover = ta.CDLDARKCLOUDCOVER(openp,
high,
low,
close,
penetration=0)
#CDLDOJI - Doji
cdldoji = ta.CDLDOJI(openp, high, low, close)
#CDLDOJISTAR - Doji Star
cdldojistar = ta.CDLDOJISTAR(openp, high, low, close)
#CDLDRAGONFLYDOJI - Dragonfly Doji
cdldragonflydoji = ta.CDLDRAGONFLYDOJI(openp, high, low, close)
#CDLENGULFING - Engulfing Pattern
cdlengulfing = ta.CDLENGULFING(openp, high, low, close)
#CDLEVENINGDOJISTAR - Evening Doji Star
cdeveningdojistar = ta.CDLEVENINGDOJISTAR(openp,
high,
low,
close,
penetration=0)
#CDLEVENINGSTAR - Evening Star
cdeveningstar = ta.CDLEVENINGSTAR(openp, high, low, close, penetration=0)
#CDLGAPSIDESIDEWHITE - Up/Down-gap side-by-side white lines
cdlgapsidesidewhite = ta.CDLGAPSIDESIDEWHITE(openp, high, low, close)
#CDLGRAVESTONEDOJI - Gravestone Doji
cdlgravestonedoji = ta.CDLGRAVESTONEDOJI(openp, high, low, close)
#CDLHAMMER - Hammer
cdlhammer = ta.CDLHAMMER(openp, high, low, close)
#CDLHANGINGMAN - Hanging Man
cdlhangman = ta.CDLHANGINGMAN(openp, high, low, close)
#CDLHARAMI - Harami Pattern
cdlharami = ta.CDLHARAMI(openp, high, low, close)
#CDLHARAMICROSS - Harami Cross Pattern
cdlharamicross = ta.CDLHARAMICROSS(openp, high, low, close)
#CDLHIGHWAVE - High-Wave Candle
cdlhighwave = ta.CDLHIGHWAVE(openp, high, low, close)
#CDLHIKKAKE - Hikkake Pattern
cdlhikakke = ta.CDLHIKKAKE(openp, high, low, close)
#CDLHIKKAKEMOD - Modified Hikkake Pattern
cdlhikkakemod = ta.CDLHIKKAKEMOD(openp, high, low, close)
#CDLHOMINGPIGEON - Homing Pigeon
cdlhomingpigeon = ta.CDLHOMINGPIGEON(openp, high, low, close)
#CDLIDENTICAL3CROWS - Identical Three Crows
cdlidentical3crows = ta.CDLIDENTICAL3CROWS(openp, high, low, close)
#CDLINNECK - In-Neck Pattern
cdlinneck = ta.CDLINNECK(openp, high, low, close)
#CDLINVERTEDHAMMER - Inverted Hammer
cdlinvertedhammer = ta.CDLINVERTEDHAMMER(openp, high, low, close)
#CDLKICKING - Kicking
cdkicking = ta.CDLKICKING(openp, high, low, close)
#CDLKICKINGBYLENGTH - Kicking - bull/bear determined by the longer marubozu
cdkickingbylength = ta.CDLKICKINGBYLENGTH(openp, high, low, close)
#CDLLADDERBOTTOM - Ladder Bottom
cdlladderbottom = ta.CDLLADDERBOTTOM(openp, high, low, close)
#CDLLONGLEGGEDDOJI - Long Legged Doji
cdllongleggeddoji = ta.CDLLONGLEGGEDDOJI(openp, high, low, close)
#CDLLONGLINE - Long Line Candle
cdllongline = ta.CDLLONGLINE(openp, high, low, close)
#CDLMARUBOZU - Marubozu
cdlmarubozu = ta.CDLMARUBOZU(openp, high, low, close)
#CDLMATCHINGLOW - Matching Low
cdlmatchinglow = ta.CDLMATCHINGLOW(openp, high, low, close)
#CDLMATHOLD - Mat Hold
cdlmathold = ta.CDLMATHOLD(openp, high, low, close, penetration=0)
#CDLMORNINGDOJISTAR - Morning Doji Star
cdlmorningdojistar = ta.CDLMORNINGDOJISTAR(openp,
high,
low,
close,
penetration=0)
#CDLMORNINGSTAR - Morning Star
cdlmorningstar = ta.CDLMORNINGSTAR(openp, high, low, close, penetration=0)
#CDLONNECK - On-Neck Pattern
cdlonneck = ta.CDLONNECK(openp, high, low, close)
#CDLPIERCING - Piercing Pattern
cdlpiercing = ta.CDLPIERCING(openp, high, low, close)
#CDLRICKSHAWMAN - Rickshaw Man
cdlrickshawman = ta.CDLRICKSHAWMAN(openp, high, low, close)
#CDLRISEFALL3METHODS - Rising/Falling Three Methods
cdlrisefall3methods = ta.CDLRISEFALL3METHODS(openp, high, low, close)
#CDLSEPARATINGLINES - Separating Lines
cdlseperatinglines = ta.CDLSEPARATINGLINES(openp, high, low, close)
#CDLSHOOTINGSTAR - Shooting Star
cdlshootingstar = ta.CDLSHOOTINGSTAR(openp, high, low, close)
#CDLSHORTLINE - Short Line Candle
cdlshortline = ta.CDLSHORTLINE(openp, high, low, close)
#CDLSPINNINGTOP - Spinning Top
cdlspinningtop = ta.CDLSPINNINGTOP(openp, high, low, close)
#CDLSTALLEDPATTERN - Stalled Pattern
cdlstalledpattern = ta.CDLSTALLEDPATTERN(openp, high, low, close)
#CDLSTICKSANDWICH - Stick Sandwich
cdlsticksandwich = ta.CDLSTICKSANDWICH(openp, high, low, close)
#CDLTAKURI - Takuri (Dragonfly Doji with very long lower shadow)
cdltakuri = ta.CDLTAKURI(openp, high, low, close)
#CDLTASUKIGAP - Tasuki Gap
cdltasukigap = ta.CDLTASUKIGAP(openp, high, low, close)
#CDLTHRUSTING - Thrusting Pattern
cdlthrusting = ta.CDLTHRUSTING(openp, high, low, close)
#CDLTRISTAR - Tristar Pattern
cdltristar = ta.CDLTRISTAR(openp, high, low, close)
#CDLUNIQUE3RIVER - Unique 3 River
cdlunique3river = ta.CDLUNIQUE3RIVER(openp, high, low, close)
#CDLUPSIDEGAP2CROWS - Upside Gap Two Crows
cdlupsidegap2crows = ta.CDLUPSIDEGAP2CROWS(openp, high, low, close)
#CDLXSIDEGAP3METHODS - Upside/Downside Gap Three Methods
cdlxsidegap3methods = ta.CDLXSIDEGAP3METHODS(openp, high, low, close)
df_save = pd.DataFrame(
data={
'date': np.array(df['date']),
'cdl2crows': cdl2crows,
'cdl3blackcrows': cdl3blackcrows,
'cdl3inside': cdl3inside,
'cdl3linestrike': cdl3linestrike,
'cdl3outside': cdl3outside,
'cdl3starinsouth': cdl3starinsouth,
'cdl3whitesoldiers': cdl3whitesoldiers,
'cdlabandonbaby': cdlabandonbaby,
'cdladvanceblock': cdladvanceblock,
'cdlbelthold': cdlbelthold,
'cdlbreakway': cdlbreakway,
'cdlclosingmarubozu': cdlclosingmarubozu,
'cdlconcealbabyswall': cdlconcealbabyswall,
'cdlcounterattack': cdlcounterattack,
'cdldarkcloudcover': cdldarkcloudcover,
'cdldoji': cdldoji,
'cdldojistar': cdldojistar,
'cdldragonflydoji': cdldragonflydoji,
'cdlengulfing': cdlengulfing,
'cdeveningdojistar': cdeveningdojistar,
'cdeveningstar': cdeveningstar,
'cdlgapsidesidewhite': cdlgapsidesidewhite,
'cdlgravestonedoji': cdlgravestonedoji,
'cdlhammer': cdlhammer,
'cdlhangman': cdlhangman,
'cdlharami': cdlharami,
'cdlharamicross': cdlharamicross,
'cdlhighwave': cdlhighwave,
'cdlhikakke': cdlhikakke,
'cdlhikkakemod': cdlhikkakemod,
'cdlhomingpigeon': cdlhomingpigeon,
'cdlidentical3crows': cdlidentical3crows,
'cdlinneck': cdlinneck,
'cdlinvertedhammer': cdlinvertedhammer,
'cdkicking': cdkicking,
'cdkickingbylength': cdkickingbylength,
'cdlladderbottom': cdlladderbottom,
'cdllongleggeddoji': cdllongleggeddoji,
'cdllongline': cdllongline,
'cdlmarubozu': cdlmarubozu,
'cdlmatchinglow': cdlmatchinglow,
'cdlmathold': cdlmathold,
'cdlmorningdojistar': cdlmorningdojistar,
'cdlmorningstar': cdlmorningstar,
'cdlonneck': cdlonneck,
'cdlpiercing': cdlpiercing,
'cdlrickshawman': cdlrickshawman,
'cdlrisefall3methods': cdlrisefall3methods,
'cdlseperatinglines': cdlseperatinglines,
'cdlshootingstar': cdlshootingstar,
'cdlshortline': cdlshortline,
'cdlspinningtop': cdlspinningtop,
'cdlstalledpattern': cdlstalledpattern,
'cdlsticksandwich': cdlsticksandwich,
'cdltakuri': cdltakuri,
'cdltasukigap': cdltasukigap,
'cdlthrusting': cdlthrusting,
'cdltristar': cdltristar,
'cdlunique3river': cdlunique3river,
'cdlupsidegap2crows': cdlupsidegap2crows,
'cdlxsidegap3methods': cdlxsidegap3methods
})
df_save.to_csv(current_dir + "/" + base_dir + "/" + out_dir + '/' +
stock_symbol + "/" + out_dir + '_ta_pattern_reognition_' +
stock_symbol + '.csv',
index=False)
from matplotlib.pylab import date2num
df_data = pd.read_csv('my_data.csv')
df_data.datetime = df_data.datetime.apply(pd.to_datetime)
df_data.set_index('datetime', drop=True, inplace=True)
Open = df_data.loc[:, 'SHFE.cu1805.open']
High = df_data.loc[:, 'SHFE.cu1805.high']
Low = df_data.loc[:, 'SHFE.cu1805.low']
Close = df_data.loc[:, 'SHFE.cu1805.close']
MACD, Signalline, MACDhist = talib.MACD(Close, fastperiod=12, slowperiod=26, signalperiod=9)
########################################
integer = talib.CDLDOJI(Open, High, Low, Close)
integer = talib.CDL3WHITESOLDIERS(Open, High, Low, Close)
integer = integer/100*Close
x = integer.where(integer!=0)
fig = plt.figure(figsize=(30, 15))
y=len(Close)
date = np.linspace(0,y,y)
candleAr = []
ax1 = plt.subplot2grid((10,4),(0,0),rowspan=5,colspan=4)
candlestick2_ochl(ax1,Open[:1000],Close[:1000],High[:1000],Low[:1000],width=1,colorup='r',colordown='g', alpha=0.75)
ax1.scatter(date[:1000], x[:1000], marker='.')
plt.savefig('2.png', dpi=300)
#plt.show()
def calc(self,stockCode):
cursor=self.connection.cursor()
cursor.execute("select date,open,high,low,close,volume from histDaily where code=%s and date>=%s and date<=%s",(stockCode,self.fromDate,self.toDate))
result = cursor.fetchall()
ohlc=[]
for row in result:
ohlc.append((row[0],row[1],row[2],row[3],row[4],row[5]))
cursor.close()
oprice=np.asfarray(np.asarray(ohlc)[:,1])
hprice=np.asfarray(np.asarray(ohlc)[:,2])
lprice=np.asfarray(np.asarray(ohlc)[:,3])
cprice=np.asfarray(np.asarray(ohlc)[:,4])
# cat a |awk '{print "self.__write(\""$1"\",stockCode,ohlc,ta."$1"(oprice,hprice,lprice,cprice))"}'
self.__write("CDL2CROWS", stockCode, ohlc, ta.CDL2CROWS(oprice, hprice, lprice, cprice))
self.__write("CDL3BLACKCROWS", stockCode, ohlc, ta.CDL3BLACKCROWS(oprice, hprice, lprice, cprice))
self.__write("CDL3INSIDE", stockCode, ohlc, ta.CDL3INSIDE(oprice, hprice, lprice, cprice))
self.__write("CDL3LINESTRIKE", stockCode, ohlc, ta.CDL3LINESTRIKE(oprice, hprice, lprice, cprice))
self.__write("CDL3OUTSIDE", stockCode, ohlc, ta.CDL3OUTSIDE(oprice, hprice, lprice, cprice))
self.__write("CDL3STARSINSOUTH", stockCode, ohlc, ta.CDL3STARSINSOUTH(oprice, hprice, lprice, cprice))
self.__write("CDL3WHITESOLDIERS", stockCode, ohlc, ta.CDL3WHITESOLDIERS(oprice, hprice, lprice, cprice))
self.__write("CDLABANDONEDBABY", stockCode, ohlc, ta.CDLABANDONEDBABY(oprice, hprice, lprice, cprice))
self.__write("CDLADVANCEBLOCK", stockCode, ohlc, ta.CDLADVANCEBLOCK(oprice, hprice, lprice, cprice))
self.__write("CDLBELTHOLD", stockCode, ohlc, ta.CDLBELTHOLD(oprice, hprice, lprice, cprice))
self.__write("CDLBREAKAWAY", stockCode, ohlc, ta.CDLBREAKAWAY(oprice, hprice, lprice, cprice))
self.__write("CDLCLOSINGMARUBOZU", stockCode, ohlc, ta.CDLCLOSINGMARUBOZU(oprice, hprice, lprice, cprice))
self.__write("CDLCONCEALBABYSWALL", stockCode, ohlc, ta.CDLCONCEALBABYSWALL(oprice, hprice, lprice, cprice))
self.__write("CDLCOUNTERATTACK", stockCode, ohlc, ta.CDLCOUNTERATTACK(oprice, hprice, lprice, cprice))
self.__write("CDLDARKCLOUDCOVER", stockCode, ohlc, ta.CDLDARKCLOUDCOVER(oprice, hprice, lprice, cprice))
self.__write("CDLDOJI", stockCode, ohlc, ta.CDLDOJI(oprice, hprice, lprice, cprice))
self.__write("CDLDOJISTAR", stockCode, ohlc, ta.CDLDOJISTAR(oprice, hprice, lprice, cprice))
self.__write("CDLDRAGONFLYDOJI", stockCode, ohlc, ta.CDLDRAGONFLYDOJI(oprice, hprice, lprice, cprice))
self.__write("CDLENGULFING", stockCode, ohlc, ta.CDLENGULFING(oprice, hprice, lprice, cprice))
self.__write("CDLEVENINGDOJISTAR", stockCode, ohlc, ta.CDLEVENINGDOJISTAR(oprice, hprice, lprice, cprice))
self.__write("CDLEVENINGSTAR", stockCode, ohlc, ta.CDLEVENINGSTAR(oprice, hprice, lprice, cprice))
self.__write("CDLGAPSIDESIDEWHITE", stockCode, ohlc, ta.CDLGAPSIDESIDEWHITE(oprice, hprice, lprice, cprice))
self.__write("CDLGRAVESTONEDOJI", stockCode, ohlc, ta.CDLGRAVESTONEDOJI(oprice, hprice, lprice, cprice))
self.__write("CDLHAMMER", stockCode, ohlc, ta.CDLHAMMER(oprice, hprice, lprice, cprice))
self.__write("CDLHANGINGMAN", stockCode, ohlc, ta.CDLHANGINGMAN(oprice, hprice, lprice, cprice))
self.__write("CDLHARAMI", stockCode, ohlc, ta.CDLHARAMI(oprice, hprice, lprice, cprice))
self.__write("CDLHARAMICROSS", stockCode, ohlc, ta.CDLHARAMICROSS(oprice, hprice, lprice, cprice))
self.__write("CDLHIGHWAVE", stockCode, ohlc, ta.CDLHIGHWAVE(oprice, hprice, lprice, cprice))
self.__write("CDLHIKKAKE", stockCode, ohlc, ta.CDLHIKKAKE(oprice, hprice, lprice, cprice))
self.__write("CDLHIKKAKEMOD", stockCode, ohlc, ta.CDLHIKKAKEMOD(oprice, hprice, lprice, cprice))
self.__write("CDLHOMINGPIGEON", stockCode, ohlc, ta.CDLHOMINGPIGEON(oprice, hprice, lprice, cprice))
self.__write("CDLIDENTICAL3CROWS", stockCode, ohlc, ta.CDLIDENTICAL3CROWS(oprice, hprice, lprice, cprice))
self.__write("CDLINNECK", stockCode, ohlc, ta.CDLINNECK(oprice, hprice, lprice, cprice))
self.__write("CDLINVERTEDHAMMER", stockCode, ohlc, ta.CDLINVERTEDHAMMER(oprice, hprice, lprice, cprice))
self.__write("CDLKICKING", stockCode, ohlc, ta.CDLKICKING(oprice, hprice, lprice, cprice))
self.__write("CDLKICKINGBYLENGTH", stockCode, ohlc, ta.CDLKICKINGBYLENGTH(oprice, hprice, lprice, cprice))
self.__write("CDLLADDERBOTTOM", stockCode, ohlc, ta.CDLLADDERBOTTOM(oprice, hprice, lprice, cprice))
self.__write("CDLLONGLEGGEDDOJI", stockCode, ohlc, ta.CDLLONGLEGGEDDOJI(oprice, hprice, lprice, cprice))
self.__write("CDLLONGLINE", stockCode, ohlc, ta.CDLLONGLINE(oprice, hprice, lprice, cprice))
self.__write("CDLMARUBOZU", stockCode, ohlc, ta.CDLMARUBOZU(oprice, hprice, lprice, cprice))
self.__write("CDLMATCHINGLOW", stockCode, ohlc, ta.CDLMATCHINGLOW(oprice, hprice, lprice, cprice))
self.__write("CDLMATHOLD", stockCode, ohlc, ta.CDLMATHOLD(oprice, hprice, lprice, cprice))
self.__write("CDLMORNINGDOJISTAR", stockCode, ohlc, ta.CDLMORNINGDOJISTAR(oprice, hprice, lprice, cprice))
self.__write("CDLMORNINGSTAR", stockCode, ohlc, ta.CDLMORNINGSTAR(oprice, hprice, lprice, cprice))
self.__write("CDLONNECK", stockCode, ohlc, ta.CDLONNECK(oprice, hprice, lprice, cprice))
self.__write("CDLPIERCING", stockCode, ohlc, ta.CDLPIERCING(oprice, hprice, lprice, cprice))
self.__write("CDLRICKSHAWMAN", stockCode, ohlc, ta.CDLRICKSHAWMAN(oprice, hprice, lprice, cprice))
self.__write("CDLRISEFALL3METHODS", stockCode, ohlc, ta.CDLRISEFALL3METHODS(oprice, hprice, lprice, cprice))
self.__write("CDLSEPARATINGLINES", stockCode, ohlc, ta.CDLSEPARATINGLINES(oprice, hprice, lprice, cprice))
self.__write("CDLSHOOTINGSTAR", stockCode, ohlc, ta.CDLSHOOTINGSTAR(oprice, hprice, lprice, cprice))
self.__write("CDLSHORTLINE", stockCode, ohlc, ta.CDLSHORTLINE(oprice, hprice, lprice, cprice))
self.__write("CDLSPINNINGTOP", stockCode, ohlc, ta.CDLSPINNINGTOP(oprice, hprice, lprice, cprice))
self.__write("CDLSTALLEDPATTERN", stockCode, ohlc, ta.CDLSTALLEDPATTERN(oprice, hprice, lprice, cprice))
self.__write("CDLSTICKSANDWICH", stockCode, ohlc, ta.CDLSTICKSANDWICH(oprice, hprice, lprice, cprice))
self.__write("CDLTAKURI", stockCode, ohlc, ta.CDLTAKURI(oprice, hprice, lprice, cprice))
self.__write("CDLTASUKIGAP", stockCode, ohlc, ta.CDLTASUKIGAP(oprice, hprice, lprice, cprice))
self.__write("CDLTHRUSTING", stockCode, ohlc, ta.CDLTHRUSTING(oprice, hprice, lprice, cprice))
self.__write("CDLTRISTAR", stockCode, ohlc, ta.CDLTRISTAR(oprice, hprice, lprice, cprice))
self.__write("CDLUNIQUE3RIVER", stockCode, ohlc, ta.CDLUNIQUE3RIVER(oprice, hprice, lprice, cprice))
self.__write("CDLUPSIDEGAP2CROWS", stockCode, ohlc, ta.CDLUPSIDEGAP2CROWS(oprice, hprice, lprice, cprice))
self.__write("CDLXSIDEGAP3METHODS", stockCode, ohlc, ta.CDLXSIDEGAP3METHODS(oprice, hprice, lprice, cprice))
self.connection.close()
self.connection2.close()
def candles(source): open = source['Open'] high = source['High'] low = source['Low'] close = source['Close'] source = source.join(pd.Series(talib.CDL2CROWS(open, high, low, close), name='CDL2CROWS')) source = source.join(pd.Series(talib.CDL3BLACKCROWS(open, high, low, close), name='CDL3BLACKCROWS')) source = source.join(pd.Series(talib.CDL3INSIDE(open, high, low, close), name='CDL3INSIDE')) source = source.join(pd.Series(talib.CDL3OUTSIDE(open, high, low, close), name='CDL3OUTSIDE')) source = source.join(pd.Series(talib.CDL3STARSINSOUTH(open, high, low, close), name='CDL3STARSINSOUTH')) source = source.join(pd.Series(talib.CDL3WHITESOLDIERS(open, high, low, close), name='CDL3WHITESOLDIERS')) source = source.join(pd.Series(talib.CDLABANDONEDBABY(open, high, low, close), name='CDLABANDONEDBABY')) source = source.join(pd.Series(talib.CDLADVANCEBLOCK(open, high, low, close), name='CDLADVANCEBLOCK')) source = source.join(pd.Series(talib.CDLBELTHOLD(open, high, low, close), name='CDLBELTHOLD')) source = source.join(pd.Series(talib.CDLBREAKAWAY(open, high, low, close), name='CDLBREAKAWAY')) source = source.join(pd.Series(talib.CDLCLOSINGMARUBOZU(open, high, low, close), name='CDLCLOSINGMARUBOZU')) source = source.join(pd.Series(talib.CDLCONCEALBABYSWALL(open, high, low, close), name='CDLCONCEALBABYSWALL')) source = source.join(pd.Series(talib.CDLCOUNTERATTACK(open, high, low, close), name='CDLCOUNTERATTACK')) source = source.join(pd.Series(talib.CDLDARKCLOUDCOVER(open, high, low, close), name='CDLDARKCLOUDCOVER')) source = source.join(pd.Series(talib.CDLDOJI(open, high, low, close), name='CDLDOJI')) source = source.join(pd.Series(talib.CDLDOJISTAR(open, high, low, close), name='CDLDOJISTAR')) source = source.join(pd.Series(talib.CDLDRAGONFLYDOJI(open, high, low, close), name='CDLDRAGONFLYDOJI')) source = source.join(pd.Series(talib.CDLENGULFING(open, high, low, close), name='CDLENGULFING')) source = source.join(pd.Series(talib.CDLEVENINGDOJISTAR(open, high, low, close), name='CDLEVENINGDOJISTAR')) source = source.join(pd.Series(talib.CDLEVENINGSTAR(open, high, low, close), name='CDLEVENINGSTAR')) source = source.join(pd.Series(talib.CDLGAPSIDESIDEWHITE(open, high, low, close), name='CDLGAPSIDESIDEWHITE')) source = source.join(pd.Series(talib.CDLGRAVESTONEDOJI(open, high, low, close), name='CDLGRAVESTONEDOJI')) source = source.join(pd.Series(talib.CDLHAMMER(open, high, low, close), name='CDLHAMMER')) source = source.join(pd.Series(talib.CDLHANGINGMAN(open, high, low, close), name='CDLHANGINGMAN')) source = source.join(pd.Series(talib.CDLHARAMI(open, high, low, close), name='CDLHARAMI')) source = source.join(pd.Series(talib.CDLHARAMICROSS(open, high, low, close), name='CDLHARAMICROSS')) source = source.join(pd.Series(talib.CDLHIGHWAVE(open, high, low, close), name='CDLHIGHWAVE')) source = source.join(pd.Series(talib.CDLHIKKAKE(open, high, low, close), name='CDLHIKKAKE')) source = source.join(pd.Series(talib.CDLHIKKAKEMOD(open, high, low, close), name='CDLHIKKAKEMOD')) source = source.join(pd.Series(talib.CDLHOMINGPIGEON(open, high, low, close), name='CDLHOMINGPIGEON')) source = source.join(pd.Series(talib.CDLIDENTICAL3CROWS(open, high, low, close), name='CDLIDENTICAL3CROWS')) source = source.join(pd.Series(talib.CDLINNECK(open, high, low, close), name='CDLINNECK')) source = source.join(pd.Series(talib.CDLINVERTEDHAMMER(open, high, low, close), name='CDLINVERTEDHAMMER')) source = source.join(pd.Series(talib.CDLKICKING(open, high, low, close), name='CDLKICKING')) source = source.join(pd.Series(talib.CDLKICKINGBYLENGTH(open, high, low, close), name='CDLKICKINGBYLENGTH')) source = source.join(pd.Series(talib.CDLLADDERBOTTOM(open, high, low, close), name='CDLLADDERBOTTOM')) source = source.join(pd.Series(talib.CDLLONGLEGGEDDOJI(open, high, low, close), name='CDLLONGLEGGEDDOJI')) source = source.join(pd.Series(talib.CDLLONGLINE(open, high, low, close), name='CDLLONGLINE')) source = source.join(pd.Series(talib.CDLMARUBOZU(open, high, low, close), name='CDLMARUBOZU')) source = source.join(pd.Series(talib.CDLMATCHINGLOW(open, high, low, close), name='CDLMATCHINGLOW')) source = source.join(pd.Series(talib.CDLMATHOLD(open, high, low, close), name='CDLMATHOLD')) source = source.join(pd.Series(talib.CDLMORNINGDOJISTAR(open, high, low, close), name='CDLMORNINGDOJISTAR')) source = source.join(pd.Series(talib.CDLMORNINGSTAR(open, high, low, close), name='CDLMORNINGSTAR')) source = source.join(pd.Series(talib.CDLONNECK(open, high, low, close), name='CDLONNECK')) source = source.join(pd.Series(talib.CDLPIERCING(open, high, low, close), name='CDLPIERCING')) source = source.join(pd.Series(talib.CDLRICKSHAWMAN(open, high, low, close), name='CDLRICKSHAWMAN')) source = source.join(pd.Series(talib.CDLRISEFALL3METHODS(open, high, low, close), name='CDLRISEFALL3METHODS')) source = source.join(pd.Series(talib.CDLSEPARATINGLINES(open, high, low, close), name='CDLSEPARATINGLINES')) source = source.join(pd.Series(talib.CDLSHOOTINGSTAR(open, high, low, close), name='CDLSHOOTINGSTAR')) source = source.join(pd.Series(talib.CDLSHORTLINE(open, high, low, close), name='CDLSHORTLINE')) source = source.join(pd.Series(talib.CDLSPINNINGTOP(open, high, low, close), name='CDLSPINNINGTOP')) source = source.join(pd.Series(talib.CDLSTALLEDPATTERN(open, high, low, close), name='CDLSTALLEDPATTERN')) source = source.join(pd.Series(talib.CDLSTICKSANDWICH(open, high, low, close), name='CDLSTICKSANDWICH')) source = source.join(pd.Series(talib.CDLTAKURI(open, high, low, close), name='CDLTAKURI')) source = source.join(pd.Series(talib.CDLTASUKIGAP(open, high, low, close), name='CDLTASUKIGAP')) source = source.join(pd.Series(talib.CDLTHRUSTING(open, high, low, close), name='CDLTHRUSTING')) source = source.join(pd.Series(talib.CDLTRISTAR(open, high, low, close), name='CDLTRISTAR')) source = source.join(pd.Series(talib.CDLUNIQUE3RIVER(open, high, low, close), name='CDLUNIQUE3RIVER')) source = source.join(pd.Series(talib.CDLUPSIDEGAP2CROWS(open, high, low, close), name='CDLUPSIDEGAP2CROWS')) source = source.join(pd.Series(talib.CDLXSIDEGAP3METHODS(open, high, low, close), name='CDLXSIDEGAP3METHODS')) return source
def TA(S, s, c):
S = S.fillna(0)
ope = numpy.asfarray(S.Open)
high = numpy.asfarray(S.High)
low = numpy.asfarray(S.Low)
close = numpy.asfarray(S.Close)
volume = numpy.asfarray(S.Volume)
##ROI calculation
ROI = [(close[i + 1] - close[i]) / close[i] for i in range(len(close) - 1)]
ROI.append(0) #add zero value for last day
d = pandas.DataFrame(ROI, index=S.index, columns=['ROI'])
d.to_csv("C:\\Users\\...\\Documents\\Data_TA\\{0}\\ROI_{1}.csv".format(
s, c))
##Baselines
try:
bah.append((S.Close['2013-04-30'] - S.Close['2002-05-01']) /
S.Close['2002-05-01'])
sah.append((-S.Close['2013-04-30'] + S.Close['2002-05-01']) /
S.Close['2002-05-01'])
except:
bah.append((S.Close['2013-04-30'] - S.Close['2002-05-02']) /
S.Close['2002-05-02'])
sah.append((-S.Close['2013-04-30'] + S.Close['2002-05-02']) /
S.Close['2002-05-02'])
rp.append(
numpy.dot(numpy.random.uniform(-1, 1, len(S)), numpy.asfarray(ROI)))
##talib application
#overlap
BBANDS = ta.BBANDS(close)
DEMA = ta.DEMA(close)
EMA = ta.EMA(close)
HT_TRENDLINE = ta.HT_TRENDLINE(close)
KAMA = ta.KAMA(close)
MA = ta.MA(close)
MAMA = ta.MAMA(close)
MIDPOINT = ta.MIDPOINT(close)
MIDPRICE = ta.MIDPRICE(high, low)
SAR = ta.SAR(high, low)
SAREXT = ta.SAREXT(high, low)
SMA = ta.SMA(close)
T3 = ta.T3(close)
TEMA = ta.TEMA(close)
TRIMA = ta.TRIMA(close)
WMA = ta.WMA(close)
#momentum
ADX = ta.ADX(high, low, close)
ADXR = ta.ADXR(high, low, close)
APO = ta.APO(close)
AROON = ta.AROON(high, low)
AROONOSC = ta.AROONOSC(high, low)
BOP = ta.BOP(ope, high, low, close)
CCI = ta.CCI(high, low, close)
CMO = ta.CMO(close)
DX = ta.DX(high, low, close)
MACD = ta.MACD(close)
MACDEXT = ta.MACDEXT(close)
MFI = ta.MFI(high, low, close, volume)
MINUS_DI = ta.MINUS_DI(high, low, close)
MINUS_DM = ta.MINUS_DM(high, low)
MOM = ta.MOM(close)
PLUS_DI = ta.PLUS_DI(high, low, close)
PLUS_DM = ta.PLUS_DM(high, low)
PPO = ta.PPO(close)
ROC = ta.ROC(close)
ROCP = ta.ROCP(close)
ROCR = ta.ROCR(close)
RSI = ta.RSI(close)
STOCH = ta.STOCH(high, low, close)
STOCHF = ta.STOCHF(high, low, close)
STOCHRSI = ta.STOCHRSI(close)
TRIX = ta.TRIX(close)
ULTOSC = ta.ULTOSC(high, low, close)
WILLR = ta.WILLR(high, low, close)
#volume
AD = ta.AD(high, low, close, volume)
ADOSC = ta.ADOSC(high, low, close, volume)
OBV = ta.OBV(close, volume)
#cycle
HT_DCPERIOD = ta.HT_DCPERIOD(close)
HT_DCPHASE = ta.HT_DCPHASE(close)
HT_PHASOR = ta.HT_PHASOR(close)
HT_SINE = ta.HT_SINE(close)
HT_TRENDMODE = ta.HT_TRENDMODE(close)
#price
AVGPRICE = ta.AVGPRICE(ope, high, low, close)
MEDPRICE = ta.MEDPRICE(high, low)
TYPPRICE = ta.TYPPRICE(high, low, close)
WCLPRICE = ta.WCLPRICE(high, low, close)
#volatility
ATR = ta.ATR(high, low, close)
NATR = ta.NATR(high, low, close)
TRANGE = ta.TRANGE(high, low, close)
#pattern
CDL2CROWS = ta.CDL2CROWS(ope, high, low, close)
CDL3BLACKCROWS = ta.CDL3BLACKCROWS(ope, high, low, close)
CDL3INSIDE = ta.CDL3INSIDE(ope, high, low, close)
CDL3LINESTRIKE = ta.CDL3LINESTRIKE(ope, high, low, close)
CDL3OUTSIDE = ta.CDL3OUTSIDE(ope, high, low, close)
CDL3STARSINSOUTH = ta.CDL3STARSINSOUTH(ope, high, low, close)
CDL3WHITESOLDIERS = ta.CDL3WHITESOLDIERS(ope, high, low, close)
CDLABANDONEDBABY = ta.CDLABANDONEDBABY(ope, high, low, close)
CDLADVANCEBLOCK = ta.CDLADVANCEBLOCK(ope, high, low, close)
CDLBELTHOLD = ta.CDLBELTHOLD(ope, high, low, close)
CDLBREAKAWAY = ta.CDLBREAKAWAY(ope, high, low, close)
CDLCLOSINGMARUBOZU = ta.CDLCLOSINGMARUBOZU(ope, high, low, close)
CDLCONCEALBABYSWALL = ta.CDLCONCEALBABYSWALL(ope, high, low, close)
CDLCOUNTERATTACK = ta.CDLCOUNTERATTACK(ope, high, low, close)
CDLDARKCLOUDCOVER = ta.CDLDARKCLOUDCOVER(ope, high, low, close)
CDLDOJI = ta.CDLDOJI(ope, high, low, close)
CDLDOJISTAR = ta.CDLDOJISTAR(ope, high, low, close)
CDLDRAGONFLYDOJI = ta.CDLDRAGONFLYDOJI(ope, high, low, close)
CDLENGULFING = ta.CDLENGULFING(ope, high, low, close)
CDLEVENINGDOJISTAR = ta.CDLEVENINGDOJISTAR(ope, high, low, close)
CDLEVENINGSTAR = ta.CDLEVENINGSTAR(ope, high, low, close)
CDLGAPSIDESIDEWHITE = ta.CDLGAPSIDESIDEWHITE(ope, high, low, close)
CDLGRAVESTONEDOJI = ta.CDLGRAVESTONEDOJI(ope, high, low, close)
CDLHAMMER = ta.CDLHAMMER(ope, high, low, close)
CDLHANGINGMAN = ta.CDLHANGINGMAN(ope, high, low, close)
CDLHARAMI = ta.CDLHARAMI(ope, high, low, close)
CDLHARAMICROSS = ta.CDLHARAMICROSS(ope, high, low, close)
CDLHIGHWAVE = ta.CDLHIGHWAVE(ope, high, low, close)
CDLHIKKAKE = ta.CDLHIKKAKE(ope, high, low, close)
CDLHIKKAKEMOD = ta.CDLHIKKAKEMOD(ope, high, low, close)
CDLHOMINGPIGEON = ta.CDLHOMINGPIGEON(ope, high, low, close)
CDLIDENTICAL3CROWS = ta.CDLIDENTICAL3CROWS(ope, high, low, close)
CDLINNECK = ta.CDLINNECK(ope, high, low, close)
CDLINVERTEDHAMMER = ta.CDLINVERTEDHAMMER(ope, high, low, close)
CDLKICKING = ta.CDLKICKING(ope, high, low, close)
CDLKICKINGBYLENGTH = ta.CDLKICKINGBYLENGTH(ope, high, low, close)
CDLLADDERBOTTOM = ta.CDLLADDERBOTTOM(ope, high, low, close)
CDLLONGLEGGEDDOJI = ta.CDLLONGLEGGEDDOJI(ope, high, low, close)
CDLLONGLINE = ta.CDLLONGLINE(ope, high, low, close)
CDLMARUBOZU = ta.CDLMARUBOZU(ope, high, low, close)
CDLMATCHINGLOW = ta.CDLMATCHINGLOW(ope, high, low, close)
CDLMATHOLD = ta.CDLMATHOLD(ope, high, low, close)
CDLMORNINGDOJISTAR = ta.CDLMORNINGDOJISTAR(ope, high, low, close)
CDLMORNINGSTAR = ta.CDLMORNINGSTAR(ope, high, low, close)
CDLONNECK = ta.CDLONNECK(ope, high, low, close)
CDLPIERCING = ta.CDLPIERCING(ope, high, low, close)
CDLRICKSHAWMAN = ta.CDLRICKSHAWMAN(ope, high, low, close)
CDLRISEFALL3METHODS = ta.CDLRISEFALL3METHODS(ope, high, low, close)
CDLSEPARATINGLINES = ta.CDLSEPARATINGLINES(ope, high, low, close)
CDLSHOOTINGSTAR = ta.CDLSHOOTINGSTAR(ope, high, low, close)
CDLSHORTLINE = ta.CDLSHORTLINE(ope, high, low, close)
CDLSPINNINGTOP = ta.CDLSPINNINGTOP(ope, high, low, close)
CDLSTALLEDPATTERN = ta.CDLSTALLEDPATTERN(ope, high, low, close)
CDLSTICKSANDWICH = ta.CDLSTICKSANDWICH(ope, high, low, close)
CDLTAKURI = ta.CDLTAKURI(ope, high, low, close)
CDLTASUKIGAP = ta.CDLTASUKIGAP(ope, high, low, close)
CDLTHRUSTING = ta.CDLTHRUSTING(ope, high, low, close)
CDLTRISTAR = ta.CDLTRISTAR(ope, high, low, close)
CDLUNIQUE3RIVER = ta.CDLUNIQUE3RIVER(ope, high, low, close)
CDLUPSIDEGAP2CROWS = ta.CDLUPSIDEGAP2CROWS(ope, high, low, close)
CDLXSIDEGAP3METHODS = ta.CDLXSIDEGAP3METHODS(ope, high, low, close)
f = numpy.column_stack(
(ATR, NATR, TRANGE, HT_DCPERIOD, HT_DCPHASE, HT_PHASOR[0],
HT_PHASOR[1], HT_SINE[0], HT_SINE[1], HT_TRENDMODE, AVGPRICE,
MEDPRICE, TYPPRICE, WCLPRICE, ADX, ADXR, APO, AROON[0], AROON[1],
AROONOSC, BOP, CCI, CMO, DX, MACD[0], MACD[1], MACD[2], MACDEXT[0],
MACDEXT[1], MACDEXT[2], MFI, MINUS_DI, MINUS_DM, MOM, PLUS_DI,
PLUS_DM, PPO, ROC, ROCP, ROCR, RSI, STOCH[0], STOCH[1], STOCHF[0],
STOCHF[1], STOCHRSI[0], STOCHRSI[1], TRIX, ULTOSC, WILLR, CDL2CROWS,
CDL3BLACKCROWS, CDL3INSIDE, CDL3LINESTRIKE, CDL3OUTSIDE,
CDL3STARSINSOUTH, CDL3WHITESOLDIERS, CDLABANDONEDBABY,
CDLADVANCEBLOCK, CDLBELTHOLD, CDLBREAKAWAY, CDLCLOSINGMARUBOZU,
CDLCONCEALBABYSWALL, CDLCOUNTERATTACK, CDLDARKCLOUDCOVER, CDLDOJI,
CDLDOJISTAR, CDLDRAGONFLYDOJI, CDLENGULFING, CDLEVENINGDOJISTAR,
CDLEVENINGSTAR, CDLGAPSIDESIDEWHITE, CDLGRAVESTONEDOJI, CDLHAMMER,
CDLHANGINGMAN, CDLHARAMI, CDLHARAMICROSS, CDLHIGHWAVE, CDLHIKKAKE,
CDLHIKKAKEMOD, CDLHOMINGPIGEON, CDLIDENTICAL3CROWS, CDLINNECK,
CDLINVERTEDHAMMER, CDLKICKING, CDLKICKINGBYLENGTH, CDLLADDERBOTTOM,
CDLLONGLEGGEDDOJI, CDLLONGLINE, CDLMARUBOZU, CDLMATCHINGLOW,
CDLMATHOLD, CDLMORNINGDOJISTAR, CDLMORNINGSTAR, CDLONNECK,
CDLPIERCING, CDLRICKSHAWMAN, CDLRISEFALL3METHODS, CDLSEPARATINGLINES,
CDLSHOOTINGSTAR, CDLSHORTLINE, CDLSPINNINGTOP, CDLSTALLEDPATTERN,
CDLSTICKSANDWICH, CDLTAKURI, CDLTASUKIGAP, CDLTHRUSTING, CDLTRISTAR,
CDLUNIQUE3RIVER, CDLUPSIDEGAP2CROWS, CDLXSIDEGAP3METHODS, BBANDS[0],
BBANDS[1], BBANDS[2], DEMA, EMA, HT_TRENDLINE, KAMA, MA, MAMA[0],
MAMA[1], MIDPOINT, MIDPRICE, SAR, SAREXT, SMA, T3, TEMA, TRIMA, WMA,
AD, ADOSC, OBV))
h = numpy.apply_along_axis(nor, 0, f) # normalize columnwise
df = pandas.DataFrame(
h,
index=S.index,
columns=[
'ATR', 'NATR', 'TRANGE', 'HT_DCPERIOD', 'HT_DCPHASE',
'HT_PHASOR[0]', 'HT_PHASOR[1]', 'HT_SINE[0]', 'HT_SINE[1]',
'HT_TRENDMODE', 'AVGPRICE', 'MEDPRICE', 'TYPPRICE', 'WCLPRICE',
'ADX', 'ADXR', 'APO', 'AROON[0]', 'AROON[1]', 'AROONOSC', 'BOP',
'CCI', 'CMO', 'DX', 'MACD[0]', 'MACD[1]', 'MACD[2]', 'MACDEXT[0]',
'MACDEXT[1]', 'MACDEXT[2]', 'MFI', 'MINUS_DI', 'MINUS_DM', 'MOM',
'PLUS_DI', 'PLUS_DM', 'PPO', 'ROC', 'ROCP', 'ROCR', 'RSI',
'STOCH[0]', 'STOCH[1]', 'STOCHF[0]', 'STOCHF[1]', 'STOCHRSI[0]',
'STOCHRSI[1]', 'TRIX', 'ULTOSC', 'WILLR', 'CDL2CROWS',
'CDL3BLACKCROWS', 'CDL3INSIDE', 'CDL3LINESTRIKE', 'CDL3OUTSIDE',
'CDL3STARSINSOUTH', 'CDL3WHITESOLDIERS', 'CDLABANDONEDBABY',
'CDLADVANCEBLOCK', 'CDLBELTHOLD', 'CDLBREAKAWAY',
'CDLCLOSINGMARUBOZU', 'CDLCONCEALBABYSWALL', 'CDLCOUNTERATTACK',
'CDLDARKCLOUDCOVER', 'CDLDOJI', 'CDLDOJISTAR', 'CDLDRAGONFLYDOJI',
'CDLENGULFING', 'CDLEVENINGDOJISTAR', 'CDLEVENINGSTAR',
'CDLGAPSIDESIDEWHITE', 'CDLGRAVESTONEDOJI', 'CDLHAMMER',
'CDLHANGINGMAN', 'CDLHARAMI', 'CDLHARAMICROSS', 'CDLHIGHWAVE',
'CDLHIKKAKE', 'CDLHIKKAKEMOD', 'CDLHOMINGPIGEON',
'CDLIDENTICAL3CROWS', 'CDLINNECK', 'CDLINVERTEDHAMMER',
'CDLKICKING', 'CDLKICKINGBYLENGTH', 'CDLLADDERBOTTOM',
'CDLLONGLEGGEDDOJI', 'CDLLONGLINE', 'CDLMARUBOZU',
'CDLMATCHINGLOW', 'CDLMATHOLD', 'CDLMORNINGDOJISTAR',
'CDLMORNINGSTAR', 'CDLONNECK', 'CDLPIERCING', 'CDLRICKSHAWMAN',
'CDLRISEFALL3METHODS', 'CDLSEPARATINGLINES', 'CDLSHOOTINGSTAR',
'CDLSHORTLINE', 'CDLSPINNINGTOP', 'CDLSTALLEDPATTERN',
'CDLSTICKSANDWICH', 'CDLTAKURI', 'CDLTASUKIGAP', 'CDLTHRUSTING',
'CDLTRISTAR', 'CDLUNIQUE3RIVER', 'CDLUPSIDEGAP2CROWS',
'CDLXSIDEGAP3METHODS', 'BBANDS[0]', 'BBANDS[1]', 'BBANDS[2]',
'DEMA', 'EMA', 'HT_TRENDLINE', 'KAMA', 'MA', 'MAMA[0]', 'MAMA[1]',
'MIDPOINT', 'MIDPRICE', 'SAR', 'SAREXT', 'SMA', 'T3', 'TEMA',
'TRIMA', 'WMA', 'AD', 'ADOSC', 'OBV'
])
df.to_csv("C:\\Users\\...\\Documents\\Data_TA\\{0}\\{1}.csv".format(s, c))
def candlestickmethod(self, dataframe):
return np.argwhere(
np.array(
talib.CDLDOJI(dataframe['open'], dataframe['high'], dataframe['low'], dataframe['close'])
)
).squeeze()
ohlc_df['high'],
ohlc_df['low'],
ohlc_df['close'])
ohlc_df['CDLCLOSINGMARUBOZU'] = ta.CDLCLOSINGMARUBOZU(
ohlc_df['open'], ohlc_df['high'], ohlc_df['low'],
ohlc_df['close'])
ohlc_df['CDLCONCEALBABYSWALL'] = ta.CDLCONCEALBABYSWALL(
ohlc_df['open'], ohlc_df['high'], ohlc_df['low'],
ohlc_df['close'])
ohlc_df['CDLCOUNTERATTACK'] = ta.CDLCOUNTERATTACK(
ohlc_df['open'], ohlc_df['high'], ohlc_df['low'],
ohlc_df['close'])
ohlc_df['CDLDARKCLOUDCOVER'] = ta.CDLDARKCLOUDCOVER(
ohlc_df['open'], ohlc_df['high'], ohlc_df['low'],
ohlc_df['close'])
ohlc_df['CDLDOJI'] = ta.CDLDOJI(ohlc_df['open'], ohlc_df['high'],
ohlc_df['low'], ohlc_df['close'])
ohlc_df['CDLDOJISTAR'] = ta.CDLDOJISTAR(ohlc_df['open'],
ohlc_df['high'],
ohlc_df['low'],
ohlc_df['close'])
ohlc_df['CDLDRAGONFLYDOJI'] = ta.CDLDRAGONFLYDOJI(
ohlc_df['open'], ohlc_df['high'], ohlc_df['low'],
ohlc_df['close'])
ohlc_df['CDLENGULFING'] = ta.CDLENGULFING(ohlc_df['open'],
ohlc_df['high'],
ohlc_df['low'],
ohlc_df['close'])
ohlc_df['CDLEVENINGDOJISTAR'] = ta.CDLEVENINGDOJISTAR(
ohlc_df['open'], ohlc_df['high'], ohlc_df['low'],
ohlc_df['close'])
ohlc_df['CDLEVENINGSTAR'] = ta.CDLEVENINGSTAR(
def CDLDOJI(self, name, **parameters):
data = self.__data[name]
return talib.CDLDOJI(data, **parameters)
def enhance_with_indicators(data):
set = []
OPEN = data[:, Candle.OPEN]
HIGH = data[:, Candle.HIGH]
LOW = data[:, Candle.LOW]
CLOSE = data[:, Candle.CLOSE]
VOLUME = data[:, Candle.VOLUME]
low_high = talib.BBANDS(CLOSE,
timeperiod=14,
nbdevup=2,
nbdevdn=2,
matype=1)
low_high = np.asarray([low_high[0][-1], low_high[2][-1]]).reshape(-1, 1)
low_high_scaler = StandardScaler()
low_high_scaler.fit(low_high)
one = np.asarray([-1, 1]).reshape(-1, 1)
one_scaler = StandardScaler()
one_scaler.fit(one)
hundred = np.asarray([-100, 100]).reshape(-1, 1)
hundred_scaler = StandardScaler()
hundred_scaler.fit(hundred)
thousand = np.asarray([-1000, 1000]).reshape(-1, 1)
thousand_scaler = StandardScaler()
thousand_scaler.fit(thousand)
million = np.asarray([-1000000, 1000000]).reshape(-1, 1)
million_scaler = StandardScaler()
million_scaler.fit(million)
set.append(scale(OPEN, low_high_scaler))
set.append(scale(HIGH, low_high_scaler))
set.append(scale(LOW, low_high_scaler))
set.append(scale(CLOSE, low_high_scaler))
#Bollinger Bands are envelopes plotted at a standard deviation level above and below a simple moving average of the price.
set.append(
scale(
talib.BBANDS(CLOSE, timeperiod=5, nbdevup=2, nbdevdn=2, matype=0),
low_high_scaler)) #121.03399999999903 19719.281591268886
set.append(
scale(
talib.BBANDS(CLOSE, timeperiod=14, nbdevup=2, nbdevdn=2, matype=1),
low_high_scaler))
#The DEMA uses two exponential moving averages (EMAs) to eliminate lag, as some traders view lag as a problem.
set.append(scale(talib.DEMA(CLOSE, timeperiod=10),
low_high_scaler)) #122.0 19573.564771355504
set.append(scale(talib.DEMA(CLOSE, timeperiod=21),
low_high_scaler)) #122.0 19546.76082510694
set.append(scale(talib.DEMA(CLOSE, timeperiod=100),
low_high_scaler)) #123.84710711425136 19578.715808186673
#However, whereas SMA simply calculates an average of price data, EMA applies more weight to data that is more current.
set.append(scale(talib.EMA(CLOSE, timeperiod=10),
low_high_scaler)) #122.0 19499.362560116417
set.append(scale(talib.EMA(CLOSE, timeperiod=21),
low_high_scaler)) #122.0 19433.26416788178
set.append(scale(talib.EMA(CLOSE, timeperiod=100),
low_high_scaler)) #122.11270000000005 19059.124645340504
#The HTTrendline at a specific bar gives the current Hilbert Transform Trendline as instantaneously measured at that
#bar. In its Series form, the Instantaneous Trendline appears much like a Moving Average, but with minimal lag
#compared with the lag normally associated with such averages for equivalent periods.
set.append(scale(talib.HT_TRENDLINE(CLOSE),
low_high_scaler)) #122.0 19471.324
#Kaufman's Adaptive Moving Average (KAMA) is a moving average designed to account for market noise or volatility.
#KAMA will closely follow prices when the price swings are relatively small and the noise is low.
set.append(scale(talib.KAMA(CLOSE, timeperiod=10),
low_high_scaler)) #122.0 19397.611724437047
set.append(scale(talib.KAMA(CLOSE, timeperiod=21),
low_high_scaler)) #122.0 19336.434082122203
set.append(scale(talib.KAMA(CLOSE, timeperiod=100),
low_high_scaler)) #123.61 19301.746826077375
#The MESA adaptive moving average is a trend-following indicator. It adapts to price movements in a very unique way,
#based on the rate of change (ROC), as measured by the Hilbert Transform Discriminator.
set.append(
scale(talib.MAMA((HIGH + LOW) / 2., fastlimit=0.5, slowlimit=0.05),
low_high_scaler)) #121.04112572694972 19494.294994956996
set.append(scale(talib.MIDPOINT(CLOSE, timeperiod=5),
low_high_scaler)) #122.0 19544.95
set.append(scale(talib.MIDPRICE(LOW, HIGH, timeperiod=5),
low_high_scaler)) #122.0 19562.6
#The parabolic SAR indicator, developed by J. Welles Wilder Jr., is used by traders to determine trend direction
# and potential reversals in price.
set.append(
scale(talib.SAR(HIGH, LOW, acceleration=0.02, maximum=0.2),
low_high_scaler)) #122.0 19660.0
#A simple moving average (SMA) is an arithmetic moving average calculated by adding recent prices and then dividing
# that figure by the number of time periods in the calculation average.
set.append(scale(talib.SMA(CLOSE, timeperiod=5),
low_high_scaler)) #122.0 19553.340000000037
set.append(scale(talib.SMA(CLOSE, timeperiod=25),
low_high_scaler)) #122.0 19405.74400000004
set.append(scale(talib.SMA(CLOSE, timeperiod=50),
low_high_scaler)) #122.0 19286.443999999996
#The Triple Exponential Moving Average (T3) developed by Tim Tillson attempts to offer a moving average with better
#smoothing then traditional exponential moving average. It incorporates a smoothing technique which allows it to
#plot curves more gradual than ordinary moving averages and with a smaller lag.
set.append(scale(talib.T3(CLOSE, timeperiod=5, vfactor=0),
low_high_scaler)) #122.0 19498.31237177043
set.append(
scale(talib.T3(CLOSE, timeperiod=10, vfactor=0),
low_high_scaler)) #122.0 19419.991324685387
set.append(
scale(talib.T3(CLOSE, timeperiod=21, vfactor=0),
low_high_scaler)) #122.84310194419339 19306.63501695168
#The triple exponential moving average was designed to smooth price fluctuations, thereby making it easier to
#identify trends without the lag associated with traditional moving averages (MA).
set.append(scale(talib.TEMA(CLOSE, timeperiod=7),
low_high_scaler)) #122.0 19617.222402494965
set.append(scale(talib.TEMA(CLOSE, timeperiod=15),
low_high_scaler)) #122.0 19586.42515855386
#The Triangular Moving Average is basically a double-smoothed Simple Moving Average that gives more weight to the
#middle section of the data interval. The TMA has a significant lag to current prices and is not well-suited to
#fast moving markets.
set.append(scale(talib.TRIMA(CLOSE, timeperiod=5),
low_high_scaler)) #122.0 19567.31111092877
set.append(scale(talib.TRIMA(CLOSE, timeperiod=25),
low_high_scaler)) #122.0 19459.8816568341
set.append(scale(talib.TRIMA(CLOSE, timeperiod=50),
low_high_scaler)) #122.0 19359.257076923175
#The weighted moving average (WMA) is a technical indicator that assigns a greater weighting to the most recent data
#points, and less weighting to data points in the distant past. The WMA is obtained by multiplying each number in
#the data set by a predetermined weight and summing up the resulting values.
set.append(scale(talib.WMA(CLOSE, timeperiod=5),
low_high_scaler)) #122.0 19567.840000466134
set.append(scale(talib.WMA(CLOSE, timeperiod=10),
low_high_scaler)) #122.0 19527.127272724356
set.append(scale(talib.WMA(CLOSE, timeperiod=21),
low_high_scaler)) #122.0 19479.342424127473
set.append(scale(talib.WMA(CLOSE, timeperiod=50),
low_high_scaler)) #122.0 19355.600000135404
set.append(scale(talib.WMA(CLOSE, timeperiod=100),
low_high_scaler)) #122.21647326732675 19265.66566335264
set.append(scale(talib.LINEARREG(CLOSE, timeperiod=14),
low_high_scaler)) # 122.0 19585.157142857144
set.append(
scale(talib.LINEARREG_INTERCEPT(CLOSE, timeperiod=14),
low_high_scaler)) #121.54000000000003 19643.968571428577
set.append(scale(talib.TSF(CLOSE, timeperiod=14),
low_high_scaler)) #122.0 19609.668131868133
#ADX stands for Average Directional Movement Index and can be used to help measure the overall strength of a trend.
#The ADX indicator is an average of expanding price range values.
set.append(
scale(talib.ADX(HIGH, LOW, CLOSE, timeperiod=10),
hundred_scaler)) #0.0 99.99999999999963
set.append(
scale(talib.ADX(HIGH, LOW, CLOSE, timeperiod=14),
hundred_scaler)) #0.0 99.9999999940751
set.append(
scale(talib.ADX(HIGH, LOW, CLOSE, timeperiod=21),
hundred_scaler)) #0.0 99.99998408446837
#ADXR stands for Average Directional Movement Index Rating. ADXR is a component of the Directional Movement System
#developed by Welles Wilder.
set.append(
scale(talib.ADXR(HIGH, LOW, CLOSE, timeperiod=14),
hundred_scaler)) #0.0 99.9999999892742
#The Aroon indicator is a technical indicator that is used to identify trend changes in the price of an asset,
#as well as the strength of that trend. In essence, the indicator measures the time between highs and the time
#between lows over a time period. ... The indicator signals when this is happening, and when it isn't
set.append(scale(talib.AROON(HIGH, LOW), hundred_scaler)) #0.0 100.0
#The Directional Movement Index, or DMI, is an indicator developed by J. ... An optional third line, called
#directional movement (DX) shows the difference between the lines. When +DI is above -DI, there is more upward
#pressure than downward pressure in the price.
set.append(scale(talib.DX(HIGH, LOW, CLOSE, timeperiod=5),
hundred_scaler)) #0.0 100.0
set.append(scale(talib.DX(HIGH, LOW, CLOSE, timeperiod=21),
hundred_scaler)) #0.0 100.0
set.append(scale(talib.DX(HIGH, LOW, CLOSE, timeperiod=50),
hundred_scaler)) #0.0 100.0
set.append(
scale(talib.MFI(HIGH, LOW, CLOSE, VOLUME, timeperiod=14),
hundred_scaler)) #-5.888410733172162e-08 100.00000000707982
set.append(
scale(talib.MFI(HIGH, LOW, CLOSE, VOLUME, timeperiod=26),
hundred_scaler)) #-1.3802451942902055e-09 100.00000001185656
set.append(
scale(talib.MFI(HIGH, LOW, CLOSE, VOLUME, timeperiod=100),
hundred_scaler)) #-5.3901183535126315e-08 100.00000000091877
set.append(
scale(talib.MINUS_DI(HIGH, LOW, CLOSE, timeperiod=14),
hundred_scaler)) #0.0 99.99999996020233
set.append(
scale(talib.PLUS_DI(HIGH, LOW, CLOSE, timeperiod=14),
hundred_scaler)) #0.0 100.0
set.append(scale(talib.RSI(CLOSE, timeperiod=14),
hundred_scaler)) #0.0 100.0
set.append(
scale(
talib.STOCH(HIGH,
LOW,
CLOSE,
fastk_period=5,
slowk_period=3,
slowk_matype=0,
slowd_period=3,
slowd_matype=0),
hundred_scaler)) #-1.0137076363510762e-12 100.00000000000279
set.append(
scale(
talib.STOCHF(HIGH,
LOW,
CLOSE,
fastk_period=5,
fastd_period=3,
fastd_matype=0),
hundred_scaler)) #-1.0137076363510762e-12 100.0000000000012
set.append(
scale(
talib.STOCHRSI(CLOSE,
timeperiod=14,
fastk_period=5,
fastd_period=3,
fastd_matype=0),
hundred_scaler)) #-1.2166564052525548e-12 100.00000000000011
set.append(
scale(
talib.ULTOSC(HIGH,
LOW,
CLOSE,
timeperiod1=7,
timeperiod2=14,
timeperiod3=28),
hundred_scaler)) # 0.0 100.00000032481957
set.append(
scale(talib.CDL3WHITESOLDIERS(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #0 100
set.append(scale(talib.CDLDOJI(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #0 100
set.append(
scale(talib.CDLDRAGONFLYDOJI(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #0 100
set.append(
scale(talib.CDLGRAVESTONEDOJI(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #0 100
set.append(scale(talib.CDLHAMMER(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #0 100
set.append(
scale(talib.CDLHOMINGPIGEON(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #0 100
set.append(
scale(talib.CDLINVERTEDHAMMER(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #0 100
set.append(
scale(talib.CDLLADDERBOTTOM(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #0 100
set.append(
scale(talib.CDLLONGLEGGEDDOJI(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #0 100
set.append(
scale(talib.CDLMATCHINGLOW(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #0 100
set.append(
scale(talib.CDLMORNINGDOJISTAR(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #0 100
set.append(
scale(talib.CDLMORNINGSTAR(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #0 100
set.append(scale(talib.CDLPIERCING(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #0 100
set.append(
scale(talib.CDLRICKSHAWMAN(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #0 100
set.append(
scale(talib.CDLSTICKSANDWICH(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #0 100
set.append(scale(talib.CDLTAKURI(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #0 100
set.append(
scale(talib.CDLUNIQUE3RIVER(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #0 100
#Absolute Price Oscillator crossing above zero is considered bullish, while crossing below zero is bearish. A
#positive indicator value indicates an upward movement, while negative readings signal a downward trend.
set.append(
scale(talib.APO(CLOSE, fastperiod=12, slowperiod=26, matype=1),
thousand_scaler)) #-536.1910463572985 443.13971636041424
set.append(scale(VOLUME, thousand_scaler))
#The Commodity Channel Index (CCI) measures the current price level relative to an average price level over a given
#period of time. CCI is relatively high when prices are far above their average.
set.append(scale(talib.CCI(HIGH, LOW, CLOSE),
thousand_scaler)) #-466.66671166042244 466.66673951370416
#Moving average convergence divergence (MACD) is a trend-following momentum indicator that shows the relationship
#between two moving averages of a security’s price.
set.append(
scale(talib.MACD(CLOSE, fastperiod=5, slowperiod=14, signalperiod=5),
thousand_scaler)) # -536.1910463572985 443.13971636041424
set.append(
scale(talib.MACD(CLOSE, fastperiod=12, slowperiod=26, signalperiod=9),
thousand_scaler)) #-536.1910463572985 443.13971636041424
set.append(
scale(talib.MACD(CLOSE, fastperiod=14, slowperiod=50, signalperiod=25),
thousand_scaler)) # -536.1910463572985 443.13971636041424
set.append(scale(talib.ATR(HIGH, LOW, CLOSE),
thousand_scaler)) #0.0 672.1715311610562
set.append(scale(talib.HT_DCPHASE(CLOSE),
hundred_scaler)) #-44.99298332517037 314.99654478107004
set.append(
scale(talib.LINEARREG_SLOPE(CLOSE, timeperiod=14),
hundred_scaler)) #-222.33604395604476 152.37032967033085
set.append(
scale(talib.STDDEV(CLOSE, timeperiod=5, nbdev=1),
thousand_scaler)) #0.0 709.4023698851089
set.append(scale(talib.MINUS_DM(HIGH, LOW, timeperiod=14),
thousand_scaler)) #0.0 2909.3760999618785
set.append(scale(talib.MOM(CLOSE, timeperiod=10),
thousand_scaler)) #-2508.0 1711.2000000000007
set.append(scale(talib.MOM(CLOSE, timeperiod=25),
thousand_scaler)) # -2508.0 1711.2000000000007
set.append(scale(talib.PLUS_DM(HIGH, LOW, timeperiod=14),
thousand_scaler)) #0.0 3697.0008310558483
set.append(scale(talib.ADOSC(HIGH, LOW, CLOSE, VOLUME),
thousand_scaler)) #-1843.4418435977714 1237.4131984846026
set.append(scale(talib.TRANGE(HIGH, LOW, CLOSE),
thousand_scaler)) #0.0 4000.0
set.append(scale(talib.HT_PHASOR(CLOSE),
thousand_scaler)) #-2873.977625168652 3422.2535328187428
#The Balance of Power indicator measures the market strength of buyers against sellers by assessing the ability of
#each side to drive prices to an extreme level. The calculation is: Balance of Power = (Close price – Open price) /
#(High price – Low price) The resulting value can be smoothed by a moving average.
set.append(scale(talib.BOP(OPEN, HIGH, LOW, CLOSE), one_scaler)) #-1.0 1.0
set.append(scale(talib.ROCP(CLOSE, timeperiod=10),
one_scaler)) #-0.30688987999999995 0.46745909457773854
set.append(scale(talib.ROCR(CLOSE, timeperiod=10),
one_scaler)) #0.69311012 1.4674590945777386
set.append(scale(talib.TRIX(CLOSE, timeperiod=30),
one_scaler)) #-0.6044429731575707 0.434667877456385
set.append(scale(talib.HT_SINE(CLOSE),
one_scaler)) #-0.9999999999996187 0.9999999999940317
set.append(scale(talib.HT_TRENDMODE(CLOSE), one_scaler)) #0 1
set.append(
scale(talib.PPO(CLOSE, fastperiod=12, slowperiod=26, matype=0),
hundred_scaler)) #-13.640389725420714 13.383459677599681
set.append(scale(talib.ROC(CLOSE, timeperiod=10),
hundred_scaler)) #-30.688987999999995 46.74590945777386
set.append(scale(talib.NATR(HIGH, LOW, CLOSE),
one_scaler)) #0.0 7.881777549670427
set.append(scale(talib.HT_DCPERIOD(CLOSE),
hundred_scaler)) #6.91050087362864 49.99951053223339
set.append(scale(talib.CORREL(HIGH, LOW, timeperiod=30),
one_scaler)) #-2.4748737341529163 2.2135943621178655
set.append(scale(talib.AD(HIGH, LOW, CLOSE, VOLUME),
million_scaler)) #-3719.2404462314116 199644.25743563366
set.append(scale(talib.OBV(CLOSE, VOLUME),
million_scaler)) #-23849.75116020021 29139.83770172981
set.append(scale(talib.BETA(HIGH, LOW, timeperiod=5),
million_scaler)) #-2971957.111723269 1250567.1172035346
set.append(
scale(talib.VAR(CLOSE, timeperiod=5, nbdev=1),
million_scaler)) #-1.4901161193847656e-07 503251.7223986089
# The Aroon Oscillator is a trend-following indicator that uses aspects of the Aroon Indicator (Aroon Up and Aroon
# Down) to gauge the strength of a current trend and the likelihood that it will continue. Readings above zero
# indicate that an uptrend is present, while readings below zero indicate that a downtrend is present.
set.append(scale(talib.AROONOSC(HIGH, LOW),
hundred_scaler)) # -100.0 100.0
# The Chande Momentum Oscillator (CMO) is a technical momentum indicator developed by Tushar Chande. The CMO
# indicator is created by calculating the difference between the sum of all recent higher closes and the sum of all
# recent lower closes and then dividing the result by the sum of all price movement over a given time period.
set.append(scale(talib.CMO(CLOSE, timeperiod=5),
hundred_scaler)) # -100.0 100.0
set.append(scale(talib.CMO(CLOSE, timeperiod=14),
hundred_scaler)) # -99.99999998652726 100.0
set.append(scale(talib.CMO(CLOSE, timeperiod=25),
hundred_scaler)) # -99.99854211548185 100.0
set.append(scale(talib.CDL3INSIDE(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 100
set.append(
scale(talib.CDL3LINESTRIKE(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 100
set.append(scale(talib.CDL3OUTSIDE(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 100
set.append(
scale(talib.CDLABANDONEDBABY(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 100
set.append(scale(talib.CDLBELTHOLD(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 100
set.append(
scale(talib.CDLBREAKAWAY(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 100
set.append(
scale(talib.CDLCLOSINGMARUBOZU(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 100
set.append(
scale(talib.CDLCOUNTERATTACK(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 100
set.append(scale(talib.CDLDOJISTAR(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 100
set.append(
scale(talib.CDLENGULFING(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 100
set.append(
scale(talib.CDLGAPSIDESIDEWHITE(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 100
set.append(scale(talib.CDLHARAMI(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 100
set.append(
scale(talib.CDLHARAMICROSS(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 100
set.append(scale(talib.CDLHIGHWAVE(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 100
set.append(scale(talib.CDLKICKING(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 100
set.append(
scale(talib.CDLKICKINGBYLENGTH(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 100
set.append(scale(talib.CDLLONGLINE(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 100
set.append(scale(talib.CDLMARUBOZU(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 100
set.append(
scale(talib.CDLRISEFALL3METHODS(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 100
set.append(
scale(talib.CDLSEPARATINGLINES(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 100
set.append(
scale(talib.CDLSHORTLINE(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 100
set.append(
scale(talib.CDLSPINNINGTOP(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 100
set.append(
scale(talib.CDLTASUKIGAP(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 100
set.append(scale(talib.CDLTRISTAR(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 100
set.append(
scale(talib.CDLXSIDEGAP3METHODS(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 100
set.append(
scale(talib.LINEARREG_ANGLE(CLOSE, timeperiod=14),
hundred_scaler)) #-89.74230272272693 89.62397563202859
set.append(
scale(talib.WILLR(HIGH, LOW, CLOSE, timeperiod=14),
hundred_scaler)) # -100.00000000000001 0.0
#The Two Crows is a three-line bearish reversal candlestick pattern. The pattern requires confirmation, that is,
#the following candles should break a trendline or the nearest support area which may be formed by the first
#candle's line. If the pattern is not confirmed it may act only as a temporary pause within an uptrend.
set.append(scale(talib.CDL2CROWS(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 0
set.append(
scale(talib.CDL3BLACKCROWS(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 0
set.append(
scale(talib.CDLADVANCEBLOCK(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) # -100 0
set.append(
scale(talib.CDLDARKCLOUDCOVER(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 0
set.append(
scale(talib.CDLEVENINGDOJISTAR(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 0
set.append(
scale(talib.CDLEVENINGSTAR(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 0
set.append(
scale(talib.CDLHANGINGMAN(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 0
set.append(
scale(talib.CDLIDENTICAL3CROWS(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 0
set.append(scale(talib.CDLINNECK(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 0
set.append(scale(talib.CDLONNECK(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 0
set.append(
scale(talib.CDLSHOOTINGSTAR(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 0
set.append(
scale(talib.CDLSTALLEDPATTERN(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 0
set.append(
scale(talib.CDLTHRUSTING(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 0
set.append(scale(talib.CDLHIKKAKE(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-200 200
set.append(
scale(talib.CDLHIKKAKEMOD(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-200 200
return np.concatenate(set)
def __generate_technical_indicators(self, close_values, high_values, low_values, open_values,
volume_values):
features = pd.DataFrame()
features['short_sma'] = talib.SMA(close_values, 5)
features['long_sma'] = talib.SMA(close_values, 20)
features['sma_diff'] = features.long_sma - features.short_sma
features['stochf0'] = talib.STOCHF(high=high_values, low=low_values, close=close_values)[0]
features['stochf1'] = talib.STOCHF(high=high_values, low=low_values, close=close_values)[1]
features['rsi'] = talib.RSI(close_values, 20)
features['ad'] = talib.AD(high=high_values, low=low_values, close=close_values, volume=volume_values)
features['dema'] = talib.DEMA(close_values)
features['ema'] = talib.EMA(close_values)
features['ht_trendiline'] = talib.HT_TRENDLINE(close_values)
features['kama'] = talib.KAMA(close_values)
features['midpoint'] = talib.MIDPOINT(close_values)
features['midprice'] = talib.MIDPRICE(high=high_values, low=low_values)
features['sar'] = talib.SAR(high=high_values, low=low_values)
features['sarext'] = talib.SAREXT(high=high_values, low=low_values)
features['adx'] = talib.ADX(high=high_values, low=low_values, close=close_values)
features['adxr'] = talib.ADXR(high=high_values, low=low_values, close=close_values)
features['apo'] = talib.APO(close_values)
features['aroon0'] = talib.AROON(high=high_values, low=low_values)[0]
features['aroon1'] = talib.AROON(high=high_values, low=low_values)[1]
features['aroonosc'] = talib.AROONOSC(high=high_values, low=low_values)
features['bop'] = talib.BOP(open=open_values, high=high_values, low=low_values, close=close_values)
features['cmo'] = talib.CMO(close_values)
features['dx'] = talib.DX(high=high_values, low=low_values, close=close_values)
features['macdfix0'] = talib.MACDFIX(close_values)[0]
features['macdfix1'] = talib.MACDFIX(close_values)[1]
features['macdfix2'] = talib.MACDFIX(close_values)[2]
features['mfi'] = talib.MFI(high=high_values, low=low_values, close=close_values, volume=volume_values)
features['minus_di'] = talib.MINUS_DI(high=high_values, low=low_values, close=close_values)
features['minus_dm'] = talib.MINUS_DM(high=high_values, low=low_values)
features['mom'] = talib.MOM(close_values)
features['plus_di'] = talib.PLUS_DI(high=high_values, low=low_values, close=close_values)
features['plus_dm'] = talib.PLUS_DM(high=high_values, low=low_values)
features['ppo'] = talib.PPO(close_values)
features['roc'] = talib.ROC(close_values)
features['stochf0'] = talib.STOCHF(high=high_values, low=low_values, close=close_values)[0]
features['stochf1'] = talib.STOCHF(high=high_values, low=low_values, close=close_values)[1]
features['stochrsi0'] = talib.STOCHRSI(close_values)[0]
features['stochrsi1'] = talib.STOCHRSI(close_values)[1]
# data_set['trix'] = talib.TRIX(close_values)
features['ultosc'] = talib.ULTOSC(high=high_values, low=low_values, close=close_values)
features['willr'] = talib.WILLR(high=high_values, low=low_values, close=close_values)
features['adosc'] = talib.ADOSC(high=high_values, low=low_values, close=close_values, volume=volume_values)
features['obv'] = talib.OBV(close_values, volume_values)
features['ht_dcperiod'] = talib.HT_DCPERIOD(close_values)
features['ht_dcphase'] = talib.HT_DCPHASE(close_values)
features['ht_phasor0'] = talib.HT_PHASOR(close_values)[0]
features['ht_phasor1'] = talib.HT_PHASOR(close_values)[1]
features['ht_sine0'] = talib.HT_SINE(close_values)[0]
features['ht_sine1'] = talib.HT_SINE(close_values)[1]
features['ht_trendmode'] = talib.HT_TRENDMODE(close_values)
features['atr'] = talib.ATR(high=high_values, low=low_values, close=close_values)
features['trange'] = talib.TRANGE(high=high_values, low=low_values, close=close_values)
features['CDL2CROWS'] = talib.CDL2CROWS(open=open_values, high=high_values, low=low_values, close=close_values)
features['CDL3BLACKCROWS'] = talib.CDL3BLACKCROWS(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDL3INSIDE'] = talib.CDL3INSIDE(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDL3LINESTRIKE'] = talib.CDL3LINESTRIKE(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDL3OUTSIDE'] = talib.CDL3OUTSIDE(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDL3STARSINSOUTH'] = talib.CDL3STARSINSOUTH(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDL3WHITESOLDIERS'] = talib.CDL3WHITESOLDIERS(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLABANDONEDBABY'] = talib.CDLABANDONEDBABY(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLADVANCEBLOCK'] = talib.CDLADVANCEBLOCK(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLBELTHOLD'] = talib.CDLBELTHOLD(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLBREAKAWAY'] = talib.CDLBREAKAWAY(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLCLOSINGMARUBOZU'] = talib.CDLCLOSINGMARUBOZU(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLCONCEALBABYSWALL'] = talib.CDLCONCEALBABYSWALL(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLCOUNTERATTACK'] = talib.CDLCOUNTERATTACK(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLDARKCLOUDCOVER'] = talib.CDLDARKCLOUDCOVER(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLDOJI'] = talib.CDLDOJI(open=open_values, high=high_values, low=low_values, close=close_values)
features['CDLDOJISTAR'] = talib.CDLDOJISTAR(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLDRAGONFLYDOJI'] = talib.CDLDRAGONFLYDOJI(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLENGULFING'] = talib.CDLENGULFING(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLEVENINGDOJISTAR'] = talib.CDLEVENINGDOJISTAR(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLEVENINGSTAR'] = talib.CDLEVENINGSTAR(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLGAPSIDESIDEWHITE'] = talib.CDLGAPSIDESIDEWHITE(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLGRAVESTONEDOJI'] = talib.CDLGRAVESTONEDOJI(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLHAMMER'] = talib.CDLHAMMER(open=open_values, high=high_values, low=low_values, close=close_values)
features['CDLHANGINGMAN'] = talib.CDLHANGINGMAN(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLHARAMI'] = talib.CDLHARAMI(open=open_values, high=high_values, low=low_values, close=close_values)
features['CDLHARAMICROSS'] = talib.CDLHARAMICROSS(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLHIGHWAVE'] = talib.CDLHIGHWAVE(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLHIKKAKE'] = talib.CDLHIKKAKE(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLHIKKAKEMOD'] = talib.CDLHIKKAKEMOD(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLHOMINGPIGEON'] = talib.CDLHOMINGPIGEON(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLIDENTICAL3CROWS'] = talib.CDLIDENTICAL3CROWS(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLINNECK'] = talib.CDLINNECK(open=open_values, high=high_values, low=low_values, close=close_values)
features['CDLINVERTEDHAMMER'] = talib.CDLINVERTEDHAMMER(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLKICKING'] = talib.CDLKICKING(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLKICKINGBYLENGTH'] = talib.CDLKICKINGBYLENGTH(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLLADDERBOTTOM'] = talib.CDLLADDERBOTTOM(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLLONGLEGGEDDOJI'] = talib.CDLLONGLEGGEDDOJI(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLLONGLINE'] = talib.CDLLONGLINE(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLMARUBOZU'] = talib.CDLMARUBOZU(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLMATCHINGLOW'] = talib.CDLMATCHINGLOW(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLMATHOLD'] = talib.CDLMATHOLD(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLMORNINGDOJISTAR'] = talib.CDLMORNINGDOJISTAR(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLMORNINGSTAR'] = talib.CDLMORNINGSTAR(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLONNECK'] = talib.CDLONNECK(open=open_values, high=high_values, low=low_values, close=close_values)
features['CDLPIERCING'] = talib.CDLPIERCING(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLRICKSHAWMAN'] = talib.CDLRICKSHAWMAN(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLRISEFALL3METHODS'] = talib.CDLRISEFALL3METHODS(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLSEPARATINGLINES'] = talib.CDLSEPARATINGLINES(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLSHOOTINGSTAR'] = talib.CDLSHOOTINGSTAR(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLSHORTLINE'] = talib.CDLSHORTLINE(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLSPINNINGTOP'] = talib.CDLSPINNINGTOP(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLSTALLEDPATTERN'] = talib.CDLSTALLEDPATTERN(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLSTICKSANDWICH'] = talib.CDLSTICKSANDWICH(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLTAKURI'] = talib.CDLTAKURI(open=open_values, high=high_values, low=low_values, close=close_values)
features['CDLTASUKIGAP'] = talib.CDLTASUKIGAP(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLTHRUSTING'] = talib.CDLTHRUSTING(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLTRISTAR'] = talib.CDLTRISTAR(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLUNIQUE3RIVER'] = talib.CDLUNIQUE3RIVER(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLUPSIDEGAP2CROWS'] = talib.CDLUPSIDEGAP2CROWS(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLXSIDEGAP3METHODS'] = talib.CDLXSIDEGAP3METHODS(open=open_values, high=high_values, low=low_values,
close=close_values)
return features
def CDLDOJI(data):
res = talib.CDLDOJI(data.open.values, data.high.values, data.low.values,
data.close.values)
return pd.DataFrame({'CDLDOJI': res}, index=data.index)
def CDLDOJI(data, **kwargs):
_check_talib_presence()
popen, phigh, plow, pclose, pvolume = _extract_ohlc(data)
return talib.CDLDOJI(popen, phigh, plow, pclose, **kwargs)
def CDLDOJI(Open, High, Low, Close):
integer = pd.DataFrame()
for i in High.columns:
integer[i] = ta.CDLDOJI(Open[i], High[i], Low[i], Close[i])
return integer
np.array(df['High']),
np.array(df['Low']),
np.array(df['Adj Close']))
df['Concealing_Baby_Swallow'] = ta.CDLCONCEALBABYSWALL(
np.array(df['Open']), np.array(df['High']), np.array(df['Low']),
np.array(df['Adj Close']))
df['Counterattack'] = ta.CDLCOUNTERATTACK(np.array(df['Open']),
np.array(df['High']),
np.array(df['Low']),
np.array(df['Adj Close']))
df['Dark_Cloud_Cover'] = ta.CDLDARKCLOUDCOVER(np.array(df['Open']),
np.array(df['High']),
np.array(df['Low']),
np.array(df['Adj Close']),
penetration=0)
df['Doji'] = ta.CDLDOJI(np.array(df['Open']), np.array(df['High']),
np.array(df['Low']), np.array(df['Adj Close']))
df['Doji_Star'] = ta.CDLDOJISTAR(np.array(df['Open']), np.array(df['High']),
np.array(df['Low']),
np.array(df['Adj Close']))
df['Dragonfly_Doji'] = ta.CDLDRAGONFLYDOJI(np.array(df['Open']),
np.array(df['High']),
np.array(df['Low']),
np.array(df['Adj Close']))
df['Engulfing_Pattern'] = ta.CDLENGULFING(np.array(df['Open']),
np.array(df['High']),
np.array(df['Low']),
np.array(df['Adj Close']))
df['Evening_Doji_Star'] = ta.CDLEVENINGDOJISTAR(np.array(df['Open']),
np.array(df['High']),
np.array(df['Low']),
np.array(df['Adj Close']),
