def Feature_Extraction_Volume(df):
df['A/D'] = tas.AD(df['high'], df['low'], df['close'], df['volume'])
df = Williams_AD(df)
df['OBV'] = tas.OBV(df['close'], df['volume'])
df['ADOSC'] = tas.ADOSC(df['high'], df['low'], df['close'], df['volume'])
df = df.fillna(0)
return df
def devfea(df, high, low, close, open, volume):
df['AD'] = talib.AD(high, low, close, volume)
df['CCI'] = talib.CCI(high, low, close)
df['macd'], df['macdsignal'], df['macdhist'] = talib.MACD(close,
fastperiod=12,
slowperiod=26,
signalperiod=9)
df['ATR'] = talib.ATR(high, low, close, timeperiod=14)
df['ADOSC'] = talib.ADOSC(high, low, close, volume)
df['ADX'] = talib.ADX(high, low, close)
df['BBANDS_upper'], df['BBANDS_mid'], df['BBANDS_lower'] = talib.BBANDS(
close)
df['RSI'] = talib.RSI(close)
df['MA5'] = talib.MA(close, 5)
df['MA10'] = talib.MA(close, 10)
df['MA20'] = talib.MA(close, 20)
df['OBV'] = talib.OBV(close, volume)
df['SAR'] = talib.SAR(high, low)
df['lgvol'] = np.log(volume)
#上影线
df['upshadow'] = np.abs(high - ((open + close) +
(np.abs(open - close))) / 2)
#下影线
df['downshadow'] = np.abs(low - ((open + close) -
(np.abs(open - close))) / 2)
return df
def handle_volume_indicators(args, axes, i, klines_df, close_times,
display_count):
# talib
if args.AD: # AD
name = 'AD'
real = talib.AD(klines_df["high"], klines_df["low"],
klines_df["close"], klines_df["volume"])
i += 1
axes[i].set_ylabel(name)
axes[i].grid(True)
axes[i].plot(close_times, real[-display_count:], "y:", label=name)
if args.ADOSC: # ADOSC
name = 'ADOSC'
real = talib.ADOSC(klines_df["high"],
klines_df["low"],
klines_df["close"],
klines_df["volume"],
fastperiod=3,
slowperiod=10)
i += 1
axes[i].set_ylabel(name)
axes[i].grid(True)
axes[i].plot(close_times, real[-display_count:], "y:", label=name)
if args.OBV: # OBV
name = 'OBV'
real = talib.OBV(klines_df["close"], klines_df["volume"])
i += 1
axes[i].set_ylabel(name)
axes[i].grid(True)
axes[i].plot(close_times, real[-display_count:], "y:", label=name)
def getRequirementData(req: ReqParam):
stocks = getStocks()
for count, ticker in enumerate(stocks):
df = data.get(ticker)
if req.condition == 1:
if req.indicatorPeriod is None:
raise ValueError('Need to provide indicator period')
df['ADX'] = talib.ADX(df['High'].values, df['Low'].values, df['Close'].values, req.indicatorPeriod)
adxMap[ticker + '_' + str(req.indicatorPeriod)] = removeNaN(df['ADX'].values)
if req.condition == 2:
if req.fastPeriod is None or req.slowPeriod is None:
raise ValueError('Need to provide fastperiod or slowperiod')
df['chaikin'] = talib.ADOSC(df['High'].values, df['Low'].values, df['Close'].values, df['Volume'].values,
req.fastPeriod, req.slowPeriod)
chaikinMap[ticker + '_' + str(req.fastPeriod) + '_' + str(req.slowPeriod)] = removeNaN(df['chaikin'].values)
if req.condition == 3:
if req.indicatorPeriod is None or req.fastPeriod is None or req.slowPeriod is None:
raise ValueError('Need to provide indicatorPeriod, fastPeriod or slowPeriod')
_, __, df['MACDHist'] = talib.MACD(df['Close'].values, fastperiod=req.fastPeriod, slowperiod=req.slowPeriod,
signalperiod=req.indicatorPeriod)
histMap[ticker + '_' + str(req.indicatorPeriod) + '_' + str(req.fastPeriod) + '_' + str(req.slowPeriod)] = \
removeNaN(df['MACDHist'].values)
if req.condition == 4:
if req.rollingPeriod is None:
raise ValueError('Need to provide rollingPeriod')
df['vol'] = np.where(df['Volume'] > df['Volume'].rolling(req.rollingPeriod).mean())
volMap[ticker + '_' + str(req.rollingPeriod)] = df['vol'].values
def updateIndicator(self, data, candles_visible):
# ADOSC(high, low, close, volume, fastperiod=3, slowperiod=10)
chaikin_oscillator = talib.ADOSC(data[2], data[3], data[4], data[5], fastperiod=3, slowperiod=10)
chaikin_oscillator = chaikin_oscillator[-candles_visible:]
self.oscillator.clear()
for i in range(candles_visible):
self.oscillator.append(i + 0.5, chaikin_oscillator[i])
# detach and remove old axes
for ax in self.oscillator.attachedAxes():
self.oscillator.detachAxis(ax)
for ax in self.axes():
self.removeAxis(ax)
# set x axes
ax = QtChart.QValueAxis()
ax.setRange(0, candles_visible)
ax.hide()
# set x axes
ay = QtChart.QValueAxis()
bound = max(abs(min(chaikin_oscillator)), max(chaikin_oscillator))
ay.setRange(-bound, bound)
ay.setGridLinePen(QtGui.QPen(QtGui.QColor(80, 80, 80), 0.5))
ay.setLinePen(QtGui.QPen(QtGui.QColor(0, 0, 0), 0.5))
ay.applyNiceNumbers()
ay.setTickCount(3)
# add and attach new axes
self.addAxis(ax, QtCore.Qt.AlignBottom)
self.addAxis(ay, QtCore.Qt.AlignRight)
self.oscillator.attachAxis(ax)
self.oscillator.attachAxis(ay)
def adosc(portfolio_item,transaction_volume, buy_threshold_difference=2, sell_threshold_difference=2, period='5d',
fastperiod=3, slowperiod=10):
"""
strategy that trades based on reversals in the chaikin oscillator
:param transaction_volume:
:param portfolio_item:
:param buy_threshold_difference:
:param sell_threshold_difference:
:param period:
:param fastperiod:
:param slowperiod:
:return:
"""
from yahooquery import Ticker
from time import sleep
from math import floor
import talib
from .TradeHistoryItem import log_trade
from API.Help import pct_change, initialize_alpaca
alpaca = initialize_alpaca()
ticker = str(portfolio_item)
yahoo_ticker = Ticker(ticker)
history = yahoo_ticker.history(period=period, interval=portfolio_item.portfolio.get_trading_frequency())
ticker_adosc = talib.ADOSC(high=history['high'], low=history['low'], close=history['close'],
volume=history['volume'], fastperiod=fastperiod, slowperiod=slowperiod)
ticker_adosc_pct = pct_change(ticker_adosc)
# Buy when in the bottom of a dip in the chalking oscillator graph
if ticker_adosc_pct[-2] < 0 and \
abs(ticker_adosc_pct[-2] - ticker_adosc_pct[-1]) > buy_threshold_difference and \
ticker_adosc_pct[-1] > 0 and portfolio_item.transaction_status != portfolio_item.BUY:
if portfolio_item.transaction_status == 2: # only buy to cover if stock has been shorted before
print('buying to cover {} shares of {}'.format(transaction_volume, ticker))
alpaca.submit_order(ticker, transaction_volume, 'buy', 'market', 'day')
portfolio_item.buy_to_cover(transaction_volume=transaction_volume)
log_trade(portfolio_item=portfolio_item, transaction_volume=transaction_volume, transaction_type=2)
sleep(1) # hopefully combats 403 alpaca error
print('buying {} shares of {}'.format(transaction_volume, ticker))
alpaca.submit_order(ticker, transaction_volume, 'buy', 'market', 'day')
portfolio_item.buy(transaction_volume=transaction_volume)
log_trade(portfolio_item=portfolio_item, transaction_volume=transaction_volume, transaction_type=0)
# Sell at a tip in chaikin oscillator
elif ticker_adosc_pct[-2] > 0 and \
abs(ticker_adosc_pct[-2] - ticker_adosc_pct[-1]) > sell_threshold_difference and \
ticker_adosc_pct[-1] < 0:
if portfolio_item.transaction_status == portfolio_item.BUY: # making sure stock exists before selling it
print('selling {} shares of {}'.format(transaction_volume, ticker))
alpaca.submit_order(ticker, transaction_volume, 'sell', 'market', 'day')
portfolio_item.sell(transaction_volume=transaction_volume)
log_trade(portfolio_item=portfolio_item, transaction_volume=transaction_volume, transaction_type=1)
sleep(1)
if portfolio_item.transaction_status != portfolio_item.SHORT: # make sure we dont short twice in a row
transaction_volume = floor(portfolio_item.cash_allocated / (
portfolio_item.ticker.price_now * 1.1)) # gives us a 10% buffer if the stock goes the other way
print('shorting {} shares of {}'.format(transaction_volume, ticker))
alpaca.submit_order(ticker, transaction_volume, 'sell', 'market', 'day')
portfolio_item.short(transaction_volume=transaction_volume)
log_trade(portfolio_item=portfolio_item, transaction_volume=transaction_volume, transaction_type=3)
def ta_ADOSC(ADOSC_conf, curr_high_price_seq, curr_low_price_seq,
curr_close_price_seq, curr_trade_price_seq):
ADOSC_seqs = []
curr_feature_list = []
ADOSC_period_num = len(ADOSC_conf["period"])
for i in range(ADOSC_period_num):
curr_fast_period = ADOSC_conf["period"][i][0]
curr_slow_period = ADOSC_conf["period"][i][1]
curr_feature_list.append("ADOSC_" + str(curr_fast_period) + "_" +
str(curr_slow_period))
curr_ADOSC_seqs = talib.ADOSC(curr_high_price_seq,
curr_low_price_seq,
curr_close_price_seq,
curr_trade_price_seq,
fastperiod=curr_fast_period,
slowperiod=curr_slow_period)
ADOSC_seqs.append(curr_ADOSC_seqs.copy())
return ADOSC_seqs, curr_feature_list
def ChaikinADOSC(high=None,
low=None,
close=None,
volume=None,
fast_period=3,
slow_period=10,
verbose=False):
"""ChaikinADOSC
Wrapper for talib.ADOSC for running unittests
on ci/cd tools that do not provide talib
.. code-block:: python
real = ADOSC(
high,
low,
close,
volume,
fastperiod=3,
slowperiod=10)
:param value: list of values
(default should be ``close``)
:param volume: list of volume values
:param verbose: show logs
"""
if verbose:
log.info('chaikinadosc - start')
return talib.ADOSC(high, low, close, volume, fast_period, slow_period)
def ADOSC_factor(self, df, fastperiod=3, slowperiod=10):
return talib.ADOSC(
df.loc[:, self.map_dict['high']].values,
df.loc[:, self.map_dict['low']].values,
df.loc[:, self.map_dict['close']].values,
df.loc[:, self.map_dict['volume']].values,
fastperiod, slowperiod)
def add_indicators(df):
high = df["HA_High"].values
close = df["HA_Close"].values
low = df["HA_Low"].values
_open = df["HA_Open"].values
volume = df["volume"].values.astype('uint32')
df["APO"] = talib.APO(close, fastperiod=9, slowperiod=21, matype=0)
df["APO"] = talib.APO(close, fastperiod=9, slowperiod=21, matype=0)
df["aroondown"], df["aroonup"] = talib.AROON(high, low, timeperiod=14)
df["BOP"] = talib.BOP(_open, high, low, close)
df["CCI"] = talib.CCI(high, low, close, timeperiod=10)
df["DX"] = talib.DX(high, low, close, timeperiod=10)
df["MOM"] = talib.MOM(close, timeperiod=10)
df["slowk"], df["slowd"] = talib.STOCH(high,
low,
close,
fastk_period=5,
slowk_period=3,
slowk_matype=0,
slowd_period=3,
slowd_matype=0)
df["OBV"] = talib.OBV(close, np.asarray(volume, dtype='float'))
df["ADOSC"] = talib.ADOSC(high,
low,
close,
np.asarray(volume, dtype='float'),
fastperiod=3,
slowperiod=10)
df["upperband"], df["middleband"], df["lowerband"] = talib.BBANDS(
close, timeperiod=5, nbdevup=2, nbdevdn=2, matype=0)
return df
def calculations(self):
'''calculations'''
self.df['rsi'] = ta.RSI(self.df['close'], timeperiod=5)
self.df['apo'] = ta.APO(self.df['close'],
fastperiod=10,
slowperiod=5,
matype=0)
self.df['upperband'], self.df['middleband'], self.df[
'lowerband'] = ta.BBANDS(self.df['close'],
timeperiod=5,
nbdevup=2,
nbdevdn=2,
matype=0)
self.df['ema'] = ta.EMA(self.df['close'], timeperiod=5)
self.df['ma'] = ta.MA(self.df['close'], timeperiod=5, matype=0)
self.df['sma'] = ta.MA(self.df['close'], timeperiod=5)
self.df['t3'] = ta.T3(self.df['close'], timeperiod=5, vfactor=0)
self.df['wma'] = ta.WMA(self.df['close'], timeperiod=5)
self.df['aroonosc'] = ta.AROONOSC(self.df['high'],
self.df['low'],
timeperiod=5)
self.df['cci'] = ta.CCI(self.df['high'],
self.df['low'],
self.df['close'],
timeperiod=5)
self.df['cmo'] = ta.CMO(self.df['close'], timeperiod=14)
self.df['macd'], self.df['macdsignal'], self.df[
'macdhist'] = ta.MACDEXT(self.df['close'],
fastperiod=12,
fastmatype=0,
slowperiod=26,
slowmatype=0,
signalperiod=9,
signalmatype=0)
self.df['slowk'], self.df['slowd'] = ta.STOCH(self.df['high'],
self.df['low'],
self.df['close'],
fastk_period=5,
slowk_period=3,
slowk_matype=0,
slowd_period=3,
slowd_matype=0)
self.df['fastk'], self.df['fastd'] = ta.STOCHRSI(self.df['close'],
timeperiod=5,
fastk_period=5,
fastd_period=3,
fastd_matype=0)
self.df['ultosc'] = ta.ULTOSC(self.df['high'],
self.df['low'],
self.df['close'],
timeperiod1=7,
timeperiod2=14,
timeperiod3=28)
self.df['adosc'] = ta.ADOSC(self.df['high'],
self.df['low'],
self.df['close'],
self.df['volume'],
fastperiod=3,
slowperiod=10)
return self.df
def calculate(data):
timestamp = data[len(data)-1][0]
nopen = []
nhigh = []
nlow = []
nclose = []
nvolume = []
for entry in data:
nopen.append(entry[1])
nhigh.append(entry[2])
nlow.append(entry[3])
nclose.append(entry[4])
nvolume.append(entry[5])
nc = np.array(nclose)
hc = np.array(nhigh)
lc = np.array(nlow)
cc = np.array(nclose)
vc = np.array(nvolume)
rsi = talib.RSI(nc, timeperiod=14)
macdsignal = talib.MACD(nc, fastperiod=12, slowperiod=26, signalperiod=9)
sar = talib.SAR(hc, lc, acceleration=0, maximum=0)
adosc = talib.ADOSC(hc, lc, cc, vc, fastperiod=3, slowperiod=10)
aroon = talib.AROONOSC(hc, lc, timeperiod=14)
ult = talib.ULTOSC(hc, lc, cc, timeperiod1=7, timeperiod2=14, timeperiod3=28)
obj, sent = twitter_api.get_sentiment()
database.insert_predictions(timestamp, rsi[-1], macdsignal[0][-1], sar[-1], adosc[-1], aroon[-1], ult[-1], sent, obj)
return timestamp, rsi[-1], macdsignal[0][-1], sar[-1], adosc[-1], aroon[-1], ult[-1], sent, obj
def technical_indicators(ohlcv_path="data/OHLC_NDX.csv"):
"""
Calculate Technical Indicators from the ti_dict dictionary and export to .csv
:param ohlcv_path: OHLCV dataset path
"""
ohlcv = pd.read_csv(ohlcv_path)
ti_dict = {
'SMA5': talib.SMA(ohlcv.Close, 5),
'SMA10': talib.SMA(ohlcv.Close, 10),
'SMA50': talib.SMA(ohlcv.Close, 50),
'EMA20': talib.EMA(ohlcv.Close, 20),
'stoch5': talib.STOCH(ohlcv.High, ohlcv.Low, ohlcv.Close, 5, 3, 0, 3, 0)[0],
'ADOSC': talib.ADOSC(ohlcv.High, ohlcv.Low, ohlcv.Close, ohlcv.Volume, fastperiod=3, slowperiod=10),
'MACDhist': talib.MACD(ohlcv.Close, fastperiod=12, slowperiod=26, signalperiod=9)[2],
'WILLR': talib.WILLR(ohlcv.High, ohlcv.Low, ohlcv.Close, timeperiod=14),
'RSI': talib.RSI(ohlcv.Close, timeperiod=14),
'MOM': talib.MOM(ohlcv.Close, timeperiod=10),
'ROC': talib.ROC(ohlcv.Close, timeperiod=10),
'OBV': talib.OBV(ohlcv.Close, ohlcv.Volume),
'CCI': talib.CCI(ohlcv.High, ohlcv.Low, ohlcv.Close, timeperiod=14)
}
# Create a dataframe from TI dictionary
df_ti = pd.DataFrame(ti_dict, index=ohlcv.index)
del ti_dict
del ohlcv
# Save Technical Indicators dataframe
if not os.path.isdir('data_preprocessed/'):
os.mkdir('data_preprocessed/')
df_ti.to_csv('data_preprocessed/technical_indicators.csv', index=False)
del df_ti
return 1
def add_adosc(self, fast_period=3, slow_period=10):
self.stk_df['ADOSC'] = talib.ADOSC(self.stk_df.high,
self.stk_df.low,
self.stk_df.close,
self.stk_df.volume,
fastperiod=fast_period,
slowperiod=slow_period)
def adosc(candles: np.ndarray,
fast_period: int = 3,
slow_period: int = 10,
sequential: bool = False) -> Union[float, np.ndarray]:
"""
ADOSC - Chaikin A/D Oscillator
:param candles: np.ndarray
:param fast_period: int - default: 3
:param slow_period: int - default: 10
:param sequential: bool - default=False
:return: float | 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:]
res = talib.ADOSC(candles[:, 3],
candles[:, 4],
candles[:, 2],
candles[:, 5],
fastperiod=fast_period,
slowperiod=slow_period)
if sequential:
return res
else:
return None if np.isnan(res[-1]) else res[-1]
def genTA(data, y, t): #t is timeperiod
indicators = {}
y_ind = copy.deepcopy(y)
for ticker in data:
## Overlap
indicators[ticker] = ta.SMA(data[ticker].iloc[:,3], timeperiod=t).to_frame()
indicators[ticker]['EMA'] = ta.EMA(data[ticker].iloc[:,3], timeperiod=t)
indicators[ticker]['BBAND_Upper'], indicators[ticker]['BBAND_Middle' ], indicators[ticker]['BBAND_Lower' ] = ta.BBANDS(data[ticker].iloc[:,3], timeperiod=t, nbdevup=2, nbdevdn=2, matype=0)
indicators[ticker]['HT_TRENDLINE'] = ta.HT_TRENDLINE(data[ticker].iloc[:,3])
indicators[ticker]['SAR'] = ta.SAR(data[ticker].iloc[:,1], data[ticker].iloc[:,2], acceleration=0, maximum=0)
#rename SMA column
indicators[ticker].rename(columns={indicators[ticker].columns[0]: "SMA"}, inplace=True)
## Momentum
indicators[ticker]['RSI'] = ta.RSI(data[ticker].iloc[:,3], timeperiod=(t-1))
indicators[ticker]['MOM'] = ta.MOM(data[ticker].iloc[:,3], timeperiod=(t-1))
indicators[ticker]['ROC'] = ta.ROC(data[ticker].iloc[:,3], timeperiod=(t-1))
indicators[ticker]['ROCP']= ta.ROCP(data[ticker].iloc[:,3],timeperiod=(t-1))
indicators[ticker]['STOCH_SLOWK'], indicators[ticker]['STOCH_SLOWD'] = ta.STOCH(data[ticker].iloc[:,1], data[ticker].iloc[:,2], data[ticker].iloc[:,3], fastk_period=t, slowk_period=int(.6*t), slowk_matype=0, slowd_period=int(.6*t), slowd_matype=0)
indicators[ticker]['MACD'], indicators[ticker]['MACDSIGNAL'], indicators[ticker]['MACDHIST'] = ta.MACD(data[ticker].iloc[:,3], fastperiod=t,slowperiod=2*t,signalperiod=int(.7*t))
## Volume
indicators[ticker]['OBV'] = ta.OBV(data[ticker].iloc[:,3], data[ticker].iloc[:,4])
indicators[ticker]['AD'] = ta.AD(data[ticker].iloc[:,1], data[ticker].iloc[:,2], data[ticker].iloc[:,3], data[ticker].iloc[:,4])
indicators[ticker]['ADOSC'] = ta.ADOSC(data[ticker].iloc[:,1], data[ticker].iloc[:,2], data[ticker].iloc[:,3], data[ticker].iloc[:,4], fastperiod=int(.3*t), slowperiod=t)
## Cycle
indicators[ticker]['HT_DCPERIOD'] = ta.HT_DCPERIOD(data[ticker].iloc[:,3])
indicators[ticker]['HT_TRENDMODE']= ta.HT_TRENDMODE(data[ticker].iloc[:,3])
## Price
indicators[ticker]['AVGPRICE'] = ta.AVGPRICE(data[ticker].iloc[:,0], data[ticker].iloc[:,1], data[ticker].iloc[:,2], data[ticker].iloc[:,3])
indicators[ticker]['TYPPRICE'] = ta.TYPPRICE(data[ticker].iloc[:,1], data[ticker].iloc[:,2], data[ticker].iloc[:,3])
## Volatility
indicators[ticker]['ATR'] = ta.ATR(data[ticker].iloc[:,1], data[ticker].iloc[:,2], data[ticker].iloc[:,3], timeperiod=(t-1))
## Statistics
indicators[ticker]['BETA'] = ta.BETA(data[ticker].iloc[:,1], data[ticker].iloc[:,2], timeperiod=(t-1))
indicators[ticker]['LINEARREG'] = ta.LINEARREG(data[ticker].iloc[:,3], timeperiod=t)
indicators[ticker]['VAR'] = ta.VAR(data[ticker].iloc[:,3], timeperiod=t, nbdev=1)
## Math Transform
indicators[ticker]['EXP'] = ta.EXP(data[ticker].iloc[:,3])
indicators[ticker]['LN'] = ta.LN(data[ticker].iloc[:,3])
## Patterns (returns integers - but norming might not really do anything but wondering if they should be normed)
indicators[ticker]['CDLENGULFING'] = ta.CDLENGULFING(data[ticker].iloc[:,0], data[ticker].iloc[:,1], data[ticker].iloc[:,2], data[ticker].iloc[:,3])
indicators[ticker]['CDLDOJI'] = ta.CDLDOJI(data[ticker].iloc[:,0], data[ticker].iloc[:,1], data[ticker].iloc[:,2], data[ticker].iloc[:,3])
indicators[ticker]['CDLHAMMER'] = ta.CDLHAMMER(data[ticker].iloc[:,0], data[ticker].iloc[:,1], data[ticker].iloc[:,2], data[ticker].iloc[:,3])
indicators[ticker]['CDLHANGINGMAN']= ta.CDLHANGINGMAN(data[ticker].iloc[:,0], data[ticker].iloc[:,1], data[ticker].iloc[:,2], data[ticker].iloc[:,3])
#drop 'nan' values
indicators[ticker].drop(indicators[ticker].index[np.arange(0,63)], inplace=True)
y_ind[ticker].drop(y_ind[ticker].index[np.arange(0,63)], inplace=True)
#Normalize Features
indicators_norm = normData(indicators)
return indicators_norm, indicators, y_ind
def adosc(candles: np.ndarray,
fastperiod=3,
slowperiod=10,
sequential=False) -> Union[float, np.ndarray]:
"""
ADOSC - Chaikin A/D Oscillator
:param candles: np.ndarray
:param fastperiod: int - default: 3
:param slowperiod: int - default: 10
:param sequential: bool - default=False
:return: float | np.ndarray
"""
if not sequential and len(candles) > 240:
candles = candles[-240:]
res = talib.ADOSC(candles[:, 3],
candles[:, 4],
candles[:, 2],
candles[:, 5],
fastperiod=fastperiod,
slowperiod=slowperiod)
if sequential:
return res
else:
return None if np.isnan(res[-1]) else res[-1]
def get_feature_df(df, company_symbol=None, feature="Trend"):
if (company_symbol != None):
df_comp = df[df["symbol"] == company_symbol]
else:
df_comp = df
df_comp = df_comp.sort_values(by=['time'])
if (feature == "Trend"):
df_comp[feature] = ta.EMA(df_comp.close, timeperiod=90)
elif (feature == "Volatility"):
df_comp[feature] = ta.ATR(df_comp.high,
df_comp.low,
df_comp.close,
timeperiod=90)
elif (feature == "Volume"):
df_comp[feature] = ta.ADOSC(df_comp.high,
df_comp.low,
df_comp.close,
df_comp.volume,
fastperiod=30,
slowperiod=90)
elif (feature == "Momemtum"):
df_comp[feature + "_1"] = ta.RSI(df_comp.close, timeperiod=90)
df_comp[feature + "_2"] = ta.ROC(df_comp.close, timeperiod=90)
elif (feature == "Open_Close"):
df_comp[feature + "_1"] = df_comp["open"]
df_comp[feature + "_2"] = df_comp["close"]
return df_comp
def add_volume_indicators(data_list):
# (volume) Indicators common for all Time-frames
for data in data_list:
# 1) AD - Chaikin A / D Line
real = talib.AD(data.High, data.Low, data.Close, data.Volume)
data['AD'] = real
# 2) ADOSC - Chaikin A/D Oscillator
real = talib.ADOSC(data.High,
data.Low,
data.Close,
data.Volume,
fastperiod=3,
slowperiod=10)
data['ADOSC'] = real
# 3) OBV - On Balance Volume
real = talib.OBV(data.Close, data.Volume)
data['OBV'] = real
data_weekly = data_list[6]
data_monthly = data_list[7]
data_15min = data_list[2]
data_daily = data_list[5]
data_60min = data_list[4]
data_1min = data_list[0]
data_5min = data_list[1]
data_30min = data_list[3]
# Create (volume) indicators for a only to a particular timeframe here..
return data_list
def Indicators(self,df): # date close open high low volume 컬럼순
# 결측치 33줄 생김 0~32 까지
df['sma5'] = talib.SMA(np.asarray(df['close']), 5)
df['sma20'] = talib.SMA(np.asarray(df['close']), 20)
#df['sma120'] = talib.SMA(np.asarray(df['close']), 120)
df['ema12'] = talib.SMA(np.asarray(df['close']), 12)
df['ema26'] = talib.SMA(np.asarray(df['close']), 26)
upper, middle, lower = talib.BBANDS(np.asarray(df['close']), timeperiod=20, nbdevup=2, nbdevdn=2, matype=0)
df['dn'] = lower
df['mavg'] = middle
df['up'] = upper
df['pctB'] = (df.close - df.dn)/(df.up - df.dn)
rsi14 = talib.RSI(np.asarray(df['close']), 14)
df['rsi14'] = rsi14
macd, macdsignal, macdhist = talib.MACD(np.asarray(df['close']), 12, 26, 9)
df['macd'] = macd
df['macdsignal'] = macdsignal
df['obv']=talib.OBV(df['close'], df['volume'])
df['ad'] = talib.AD(df['high'], df['low'], df['close'], df['volume'])
df['ADOSC'] = talib.ADOSC(df['high'], df['low'], df['close'], df['volume'], fastperiod=3, slowperiod=10)
df=df.iloc[33:]
df=df.fillna(0)
df=df.drop(columns=['date'])
self.add_columns_data = df
def ADOSC(high, low, close, volume, fastperiod=3, slowperiod=10):
# Chaikin A/D Oscillator
param = {
'fastperiod': fastperiod,
'slowperiod': slowperiod,
}
return talib.ADOSC(high, low, close, volume, **param)
def adosc(self, n, array=False):
"""
ADOSC.
"""
result = talib.ADOSC(self.high, self.low, self.close, self.volume, n)
if array:
return result
return result[-1]
def Chaikin(df):
chaikin = talib.ADOSC(np.array(df.high), np.array(df.low),
np.array(df.close), np.array(df.volume))
buy_signal = np.where(np.isnan(chaikin), chaikin,
np.where(chaikin > 0, 1, 0))
sell_signal = np.where(np.isnan(chaikin), chaikin,
np.where(chaikin < 0, 1, 0))
return (buy_signal, sell_signal)
def adosc(self, n: int, array: bool = False) -> Union[float, np.ndarray]:
"""
ADOSC.
"""
result = talib.ADOSC(self.high, self.low, self.close, self.volume, n)
if array:
return result
return result[-1]
def adosc(self, fastperiod=3,slowperiod = 10, array: bool = False) -> Union[float, np.ndarray]:
"""
ADOSC.
"""
result = talib.ADOSC(self.high, self.low, self.close, self.volume, fastperiod,slowperiod)
if array:
return result
return result[-1]
def LoadData(self):
ds = YahooStockDataSource(cachedFolderName=cachedFolderName,
dataSetId=dataSetId,
instrumentIds=self.instrumentIds,
startDateStr=startDateStr,
endDateStr=endDateStr,
event='history')
self.stkData = [ds.getBookDataByFeature()['open'],
ds.getBookDataByFeature()['high'],
ds.getBookDataByFeature()['low'],
ds.getBookDataByFeature()['close'],
ds.getBookDataByFeature()['adjClose'],
ds.getBookDataByFeature()['volume']]
tbRSI = tb.RSI(self.stkData[4][self.instrumentIds[0]],14)
tbChaikin = tb.ADOSC(self.stkData[1][self.instrumentIds[0]],
self.stkData[2][self.instrumentIds[0]],
self.stkData[3][self.instrumentIds[0]],
self.stkData[5][self.instrumentIds[0]])
'''
Task1
Create new dataframe here with 5 columns
column 1 : Date of stock price
column 2 : Day of the week (Monday Tuesday etc)
Columnn 3 : tbRSI
Column 4 : tbChaikin
column 5 : Stock's adjusted price.
Index : column1
'''
dfdata = {'Adj_Close':self.stkData[4][self.instrumentIds[0]],
'RSI':tbRSI,
'Chaikin':tbChaikin}
df = pd.DataFrame(dfdata)
df['Trade_Date'] = pd.to_datetime(df.index)
df['day_of_week'] = df['Trade_Date'].dt.day_name()
dfFinal = df[["Trade_Date", "day_of_week", "RSI", "Chaikin", "Adj_Close"]]
# dfFinal2 = df[["Trade_Date", "day_of_week", "RSI", "Chaikin", "Adj_Close"]]
#df_rsi = pd.DataFrame(dfFinal['RSI'])
#print(df_rsi)
#df_rsi.to_csv('yahooData/weeklyTradeTest/RSI_Value.csv')
'''
Task 2
filter above dataframe using column 2 value (e.g. 'Wednesday') and store in other dataframe
'''
# dfFinal2 = dfFinal.loc[df['day_of_week'] == 'Wednesday']
# dfFinal.to_csv(dir_path)
# print(dfFinal.head(50)
# dfFinal = dfFinal.loc[df['day_of_week'] == 'Friday']
dfFinal.to_csv(dir_path)
print(dfFinal.head(50))
def __ta_array_adosc(cls, high, low, close, volume, fastperiod,
slowperiod):
high_array = np.array(high)
low_array = np.array(low)
close_array = np.array(close)
volume_array = np.array(volume)
return talib.ADOSC(high_array, low_array, close_array, volume_array,
fastperiod, slowperiod)
def getVolumeIndicators(df):
high = df['High']
low = df['Low']
close = df['Close']
open = df['Open']
volume = df['Volume']
df['AD'] = ta.AD(high, low, close, volume)
df['ADOSC'] = ta.ADOSC(high, low, close, volume, fastperiod=3, slowperiod=10)
df['OBV']= ta.OBV(close, volume)
def adosc(prices, signal):
"""
Accumulation / Distribution Oscillator
"""
signal['data'] = talib.ADOSC(prices['high'],
prices['low'],
prices['close'],
prices['volume'],
fastperiod=3,
slowperiod=10).to_numpy()[:, None]
def get_adosc(ohlc):
adosc = ta.ADOSC(ohlc['2_high'],
ohlc['3_low'],
ohlc['4_close'],
ohlc['5_volume'],
fastperiod=3,
slowperiod=10)
ohlc['adosc'] = adosc
return ohlc
