def stoch(
s_interval: str,
df_stock: pd.DataFrame,
fastkperiod: int,
slowdperiod: int,
slowkperiod: int,
):
"""Stochastic oscillator
Parameters
----------
s_interval: str
Stock time interval
df_stock: pd.DataFrame
Dataframe of prices
fastkperiod : int
Fast k period
slowdperiod : int
Slow d period
slowkperiod : int
Slow k period
Returns
----------
df_ta: pd.DataFrame
Dataframe of technical indicator
"""
# Daily
if s_interval == "1440min":
df_ta = ta.stoch(
high=df_stock["High"],
low=df_stock["Low"],
close=df_stock["Adj Close"],
k=fastkperiod,
d=slowdperiod,
smooth_k=slowkperiod,
).dropna()
# Intraday
else:
df_ta = ta.stoch(
high=df_stock["High"],
low=df_stock["Low"],
close=df_stock["Close"],
k=fastkperiod,
d=slowdperiod,
smooth_k=slowkperiod,
).dropna()
return pd.DataFrame(df_ta)
def stochos(bs):
b = ta.stoch(bs['high'],
bs['low'],
bs['close'],
fast_k=None,
slow_k=None,
slow_d=None,
offset=None)
b.plot()
def get_stoch_values(inputs):
stoch_values = ta.stoch(inputs['high'], inputs['low'], inputs['close'])
ret_dict = {}
ret_dict['slowk'] = stoch_values['STOCHk_14_3_3'].dropna().round(
2).values.tolist()
ret_dict['slowd'] = stoch_values['STOCHd_14_3_3'].dropna().round(
2).values.tolist()
return ret_dict
def get_stoch_values(inputs):
stoch_values = ta.stoch(inputs['high'], inputs['low'], inputs['close'])
#print(stoch_values)
ret_dict = {}
try:
ret_dict['slowk'] = stoch_values['STOCHk_5'].values.tolist()[-items_ret:]
ret_dict['slowd'] = stoch_values['STOCHd_3'].values.tolist()[-items_ret:]
pass
except KeyError:
pass
#print(ret_dict)
return ret_dict
def indicator_adder(df):
'''
this adds the most common indicators to a dataframe
with lower case close open high low volume
takes: dataframe
returns : dataframe
'''
df['rsi'] = pta.rsi(df.close)
df['riz'] = pta.rsi(df.close,length=2)
df['vwap'] = pta.vwap(df.high,df.low,df.close,df.volume)
df[['stoch_k','stoch_d']] = pta.stoch(df.high,df.low,df.close)
if len(df)>20:
df['ema'] = pta.ema(df.close,length=20)
#if len(df)>6:
#df = super_trend(df)
return df
def get_stoch_values(inputs):
stoch_values = ta.stoch(inputs['high'], inputs['low'], inputs['close'])
resp_array = []
slowk_dict = {}
slowk_dict['name'] = "slowk"
slowk_dict['data'] = stoch_values['STOCHk_14_3_3'].dropna().round(2).values.tolist()
resp_array.append(slowk_dict)
slowd_dict = {}
slowd_dict['name'] = "slowd"
slowd_dict['data'] = stoch_values['STOCHd_14_3_3'].dropna().round(2).values.tolist()
resp_array.append(slowd_dict)
return resp_array
def on_candle(self, symbol, candles, db):
candle = candles.iloc[-1]
hours = int(datetime.strftime(candle.date, '%H'))
mins = int(datetime.strftime(candle.date, '%M'))
macdDf = ta.macd(close=candles['close'], fast=12, slow=21, signal=9)
stochDf = ta.stoch(high=candles['high'],
low=candles['low'],
close=candles['close'])
macd = macdDf.iloc[-1]['MACD_12_21_9']
macd_signal = macdDf.iloc[-1]['MACDs_12_21_9']
stoch = stochDf.iloc[-1]['STOCHk_14_3_3']
prev_stoch = stochDf.iloc[-2]['STOCHk_14_3_3']
#print(candle.date, 'macd>signal:', macd > macd_signal, 'stoch>30:', stoch>30, 'stoch>prev_stoch:', stoch > prev_stoch)
buy_signal = bool(macd > macd_signal and stoch > 30
and stoch > prev_stoch)
#donchian_low = ta.donchian(candles["high"], candles["low"], 20, 20).iloc[-1]["DCL_20_20"]
#self.plotter.addPtToLine(symbol, 'Donchian Low', candle.date, donchian_low)
#self.check_positions(candle, candles)
def getSl(candle, candles):
atr60 = ta.atr(candles["high"],
candles["low"],
candles["close"],
length=60,
mamode="ema").iloc[-1]
return candle['low'] - atr60
if buy_signal and not self.trader.position_open_symbol(symbol):
self.sl = getSl(candle, candles)
self.plotter.addPtToPointsGroup(symbol, 'SL', candle['date'],
self.sl)
self.pos_ids[symbol] = self.trader.openPosition(
symbol, 'buy', 1, candle['close'], candle['date'], self.sl)
elif self.trader.position_open_symbol(symbol):
updated_sl = getSl(candle, candles)
if updated_sl > self.sl:
self.sl = updated_sl
self.plotter.addPtToPointsGroup(symbol, 'SL', candle['date'],
self.sl)
if candle['low'] < self.sl:
self.trader.closePosition(self.pos_ids[symbol], self.sl,
candle['date'], 'Hit stop loss')
def stoch(
high_vals: pd.Series,
low_vals: pd.Series,
close_vals: pd.Series,
fastkperiod: int = 14,
slowdperiod: int = 3,
slowkperiod: int = 3,
):
"""Stochastic oscillator
Parameters
----------
high_vals: pd.Series
High values
low_vals: pd.Series
Low values
close-vals: pd.Series
Close values
fastkperiod : int
Fast k period
slowdperiod : int
Slow d period
slowkperiod : int
Slow k period
Returns
----------
pd.DataFrame
Dataframe of technical indicator
"""
return pd.DataFrame(
ta.stoch(
high=high_vals,
low=low_vals,
close=close_vals,
k=fastkperiod,
d=slowdperiod,
smooth_k=slowkperiod,
).dropna()
)
def candle_buy(df,candle='',stoch=True,stoch_thresh=30,plot=True,return_list=False):
'''
adds buy candel of the 12 with the option of combining it with stochastic threshhold...
TAKES:
1.df
2.stoch - bool True if you want to combine stoch condition
3.stoch_thresh
4.plot - returns trigger plot
returns:
'buy' column for triggers and targets to be worked out
'''
the_twelve(df,return_list)
#df['short_line'] = talib.CDLSHORTLINE(df.open,df.high,df.low,df.close)
df['buy'] = df[candle].replace(100,True).replace(-100,False).replace(0,False)
if stoch == True:
df[['fast_sto','slow_sto']] = pta.stoch(df.high,df.low,df.close)
df['buy'] = (df['buy']==True) & ( df['fast_sto']<stoch_thresh)
if plot==True:
df['buy_scale'] = df['buy'].replace(True,1).replace(1,df.close)
df[['buy_scale','close']].iplot(theme='solar',fill=True)
def get_stochastics(source):
'''
### Generate Stochastic
# import pandas_ta as ta #https://github.com/twopirllc/pandas-ta
# help(ta.stoch)
# from talib import STOCH
import pandas_ta as ta # https://github.com/twopirllc/pandas-ta
# Recommended stochastics: [fk, sk, sd], [5,3,3], [21,7,7], [21,14,14]
'''
fastk_parameter = [14, 13, 5, 21, 21, 3]
slowk_parameter = [3, 3, 3, 7, 14, 14]
slowd_parameter = [3, 8, 3, 7, 14, 14]
close = source['Close']
high = source['High']
low = source['Low']
stoch_features = pd.DataFrame(index=source.index)
for fk, sk, sd in zip(fastk_parameter, slowk_parameter, slowd_parameter):
print("Parameter: fastk={}, slowk={}, slowd={}".format(fk, sk, sd))
df = ta.stoch(high, low, close, k=fk, d=sk, smooth_k=sd)
# print(df.columns)
# print(pd.Series(df['STOCH_' + str(sk)], name='Stoch_Sk' + str(fk)+str(sk)+str(sd)))
stoch_features = stoch_features.join(
pd.Series(df['STOCHk_' + str(fk) + "_" + str(sk) + "_" + str(sd)],
name='Stoch_Sk' + str(fk) + str(sk) + str(sd)))
stoch_features = stoch_features.join(
pd.Series(df['STOCHd_' + str(fk) + "_" + str(sk) + "_" + str(sd)],
name='Stoch_Sd' + str(fk) + str(sk) + str(sd)))
print("Number of features: {}".format(stoch_features.shape))
print(stoch_features.head(5))
return stoch_features
for ticker in tickers:
# retrieve security data
df = pdr.DataReader(ticker,
data_source='yahoo',
start=start_date,
end=end_date)
# create ta indicators
df[rsi] = ta.rsi(df['Adj Close'], length=rsi_length) # rsi
df[[lower_bband, mean,
upper_bband]] = ta.bbands(df['Adj Close'],
length=bband_length,
std=bband_std) # bollinger bands
df[[stochk, stochd]] = ta.stoch(df.High,
df.Low,
df['Adj Close'],
k=stoch_k,
d=stoch_d,
smooth_k=stoch_smoothk)
df[[macd, macdh, macds]] = ta.macd(df['Adj Close'],
fast=macd_fast,
slow=macd_slow,
signal=macd_signal)
# push data to screener
screener.loc[ticker] = df.drop(
['High', 'Low', 'Open', 'Close', 'Volume'],
1).iloc[-1].round(2) # latest recent indicators values, to 2 decimals
screener.loc[ticker, 'LAST'] = df['Adj Close'].iloc[-1].round(
2) # last price, to 2 decimals
screener.loc[ticker, 'MACDsignal'] = macd_score(
df[macd],
def getStochasticIndicator(data):
stoch = ta.stoch(data["high"], data["low"], data["close"])
return stoch
def integrate_with_indicators_forecasting(input_path, output_path, start_date,
test_set, end_date_for_clustering):
folder_creator(PATH_INTEGRATED_FOLDER, 1)
for crypto in os.listdir(input_path):
for date_to_predict in test_set:
#end_date=pd.to_datetime(date_to_predict) - timedelta(days=1)
end_date = date_to_predict
df = cut_dataset_by_range(input_path,
crypto.replace(".csv", ""),
start_date,
end_date,
features_to_use=None)
df["Date"] = pd.to_datetime(df["Date"])
day_to_predict = df.loc[len(df.Date) - 1]
df = df[:-1] #remove the day to predict
#df = df.sort_values('Date', ascending=True)
data_series_of_target_feature = df[TARGET_FEATURE]
for lookback_value in LOOKBACK_TEST:
df['VWAP'] = panda.vwap(df['High'],
df['Low'],
df['Close'],
df['Volume'],
lookback_value=lookback_value)
for lookback_value in LOOKBACK_TEST:
df[str('SMA_' + str(lookback_value))] = get_SMA(
data_series_of_target_feature, lookback_value)
for lookback_value in LOOKBACK_TEST:
df[str('EMA_' + str(lookback_value))] = get_EMA(
data_series_of_target_feature, lookback_value)
for lookback_value in LOOKBACK_TEST:
df[str('RSI_' + str(lookback_value))] = get_RSI(
data_series_of_target_feature, lookback_value)
df_macd = get_MACD(data_series_of_target_feature)
df['MACD_12_26_9'] = df_macd['MACD_12_26_9']
df['MACDH_12_26_9'] = df_macd['MACDH_12_26_9']
df['MACDS_12_26_9'] = df_macd['MACDS_12_26_9']
df_bbs = panda.bbands(data_series_of_target_feature)
df['BBL_20'] = df_bbs['BBL_20']
df['BBM_20'] = df_bbs['BBM_20']
df['BBU_20'] = df_bbs['BBU_20']
df['MOM'] = panda.mom(data_series_of_target_feature)
df_stoch = panda.stoch(df['High'], df['Low'], df['Close'])
df['STOCHF_14'] = df_stoch['STOCHF_14']
df['STOCHF_3'] = df_stoch['STOCHF_3']
df['STOCH_5'] = df_stoch['STOCH_5']
df['STOCH_3'] = df_stoch['STOCH_3']
df['CMO'] = panda.cmo(data_series_of_target_feature)
df['DPO'] = panda.dpo(data_series_of_target_feature)
df['UO'] = panda.uo(df['High'], df['Low'], df['Close'])
df['lag_1'] = df['Close'].shift(1)
"""df['lag_7'] = df['Close'].shift(7)
df = df.iloc[7:]"""
df = df.append(day_to_predict, ignore_index=True)
df.fillna(value=0, inplace=True)
df.to_csv(os.path.join(
output_path,
crypto.replace(".csv", "") + str("_" + date_to_predict) +
".csv"),
sep=",",
index=False)
def stoch(l_args, s_ticker, s_interval, df_stock):
parser = argparse.ArgumentParser(
add_help=False,
prog="stoch",
description="""
The Stochastic Oscillator measures where the close is in relation
to the recent trading range. The values range from zero to 100. %D values over 75
indicate an overbought condition; values under 25 indicate an oversold condition.
When the Fast %D crosses above the Slow %D, it is a buy signal; when it crosses
below, it is a sell signal. The Raw %K is generally considered too erratic to use
for crossover signals.
""",
)
parser.add_argument(
"-k",
"--fastkperiod",
action="store",
dest="n_fastkperiod",
type=check_positive,
default=14,
help="The time period of the fastk moving average",
)
parser.add_argument(
"-d",
"--slowdperiod",
action="store",
dest="n_slowdperiod",
type=check_positive,
default=3,
help="The time period of the slowd moving average",
)
parser.add_argument(
"--slowkperiod",
action="store",
dest="n_slowkperiod",
type=check_positive,
default=3,
help="The time period of the slowk moving average",
)
parser.add_argument(
"-o",
"--offset",
action="store",
dest="n_offset",
type=check_positive,
default=0,
help="offset",
)
try:
ns_parser = parse_known_args_and_warn(parser, l_args)
if not ns_parser:
return
# Daily
if s_interval == "1440min":
df_ta = ta.stoch(
high=df_stock["High"],
low=df_stock["Low"],
close=df_stock["Adj Close"],
k=ns_parser.n_fastkperiod,
d=ns_parser.n_slowdperiod,
smooth_k=ns_parser.n_slowkperiod,
offset=ns_parser.n_offset,
).dropna()
# Intraday
else:
df_ta = ta.stoch(
high=df_stock["High"],
low=df_stock["Low"],
close=df_stock["Close"],
k=ns_parser.n_fastkperiod,
d=ns_parser.n_slowdperiod,
smooth_k=ns_parser.n_slowkperiod,
offset=ns_parser.n_offset,
).dropna()
plt.figure(figsize=plot_autoscale(), dpi=PLOT_DPI)
plt.subplot(211)
if s_interval == "1440min":
plt.plot(df_stock.index, df_stock["Adj Close"].values, "k", lw=2)
else:
plt.plot(df_stock.index, df_stock["Close"].values, "k", lw=2)
plt.title(f"Stochastic Relative Strength Index (STOCH RSI) on {s_ticker}")
plt.xlim(df_stock.index[0], df_stock.index[-1])
plt.ylabel("Share Price ($)")
plt.grid(b=True, which="major", color="#666666", linestyle="-")
plt.minorticks_on()
plt.grid(b=True, which="minor", color="#999999", linestyle="-", alpha=0.2)
plt.subplot(212)
plt.plot(df_ta.index, df_ta.iloc[:, 0].values, "k", lw=2)
plt.plot(df_ta.index, df_ta.iloc[:, 1].values, "b", lw=2, ls="--")
plt.xlim(df_stock.index[0], df_stock.index[-1])
plt.axhspan(80, 100, facecolor="r", alpha=0.2)
plt.axhspan(0, 20, facecolor="g", alpha=0.2)
plt.axhline(80, linewidth=3, color="r", ls="--")
plt.axhline(20, linewidth=3, color="g", ls="--")
plt.legend([f"%K {df_ta.columns[0]}", f"%D {df_ta.columns[1]}"])
plt.xlabel("Time")
plt.grid(b=True, which="major", color="#666666", linestyle="-")
plt.minorticks_on()
plt.grid(b=True, which="minor", color="#999999", linestyle="-", alpha=0.2)
plt.ylim([0, 100])
plt.gca().twinx()
plt.ylim(plt.gca().get_ylim())
plt.yticks([0.1, 0.9], ("OVERSOLD", "OVERBOUGHT"))
if gtff.USE_ION:
plt.ion()
plt.show()
print("")
except Exception as e:
print(e)
print("")
def stoch(l_args, s_ticker, s_interval, df_stock):
parser = argparse.ArgumentParser(
prog='stoch',
description=
""" The Stochastic Oscillator measures where the close is in relation
to the recent trading range. The values range from zero to 100. %D values over 75
indicate an overbought condition; values under 25 indicate an oversold condition.
When the Fast %D crosses above the Slow %D, it is a buy signal; when it crosses
below, it is a sell signal. The Raw %K is generally considered too erratic to use
for crossover signals. """)
parser.add_argument('-k',
"--fastkperiod",
action="store",
dest="n_fastkperiod",
type=check_positive,
default=14,
help='The time period of the fastk moving average')
parser.add_argument('-d',
"--slowdperiod",
action="store",
dest="n_slowdperiod",
type=check_positive,
default=3,
help='TThe time period of the slowd moving average')
parser.add_argument("--slowkperiod",
action="store",
dest="n_slowkperiod",
type=check_positive,
default=3,
help='The time period of the slowk moving average')
parser.add_argument('-o',
"--offset",
action="store",
dest="n_offset",
type=check_positive,
default=0,
help='offset')
try:
(ns_parser, l_unknown_args) = parser.parse_known_args(l_args)
if l_unknown_args:
print(
f"The following args couldn't be interpreted: {l_unknown_args}\n"
)
return
# Daily
if s_interval == "1440min":
df_ta = ta.stoch(high=df_stock['2. high'],
low=df_stock['3. low'],
close=df_stock['5. adjusted close'],
k=ns_parser.n_fastkperiod,
d=ns_parser.n_slowdperiod,
smooth_k=ns_parser.n_slowkperiod,
offset=ns_parser.n_offset).dropna()
plt.subplot(211)
plt.plot(df_stock.index,
df_stock['5. adjusted close'].values,
'k',
lw=2)
plt.title(
f"Stochastic Relative Strength Index (STOCH RSI) on {s_ticker}"
)
plt.xlim(df_stock.index[0], df_stock.index[-1])
plt.ylabel(f'Share Price ($)')
plt.grid(b=True, which='major', color='#666666', linestyle='-')
plt.minorticks_on()
plt.grid(b=True,
which='minor',
color='#999999',
linestyle='-',
alpha=0.2)
plt.subplot(212)
plt.plot(df_ta.index, df_ta.iloc[:, 0].values, 'k', lw=2)
plt.plot(df_ta.index, df_ta.iloc[:, 1].values, 'b', lw=2, ls='--')
plt.xlim(df_stock.index[0], df_stock.index[-1])
plt.axhspan(80, 100, facecolor='r', alpha=0.2)
plt.axhspan(0, 20, facecolor='g', alpha=0.2)
plt.axhline(80, linewidth=3, color='r', ls='--')
plt.axhline(20, linewidth=3, color='g', ls='--')
plt.legend([f'%K {df_ta.columns[0]}', f'%D {df_ta.columns[1]}'])
plt.xlabel('Time')
plt.grid(b=True, which='major', color='#666666', linestyle='-')
plt.minorticks_on()
plt.grid(b=True,
which='minor',
color='#999999',
linestyle='-',
alpha=0.2)
plt.ylim([0, 100])
plt.gca().twinx()
plt.ylim(plt.gca().get_ylim())
plt.yticks([.1, .9], ('OVERSOLD', 'OVERBOUGHT'))
plt.show()
# Intraday
else:
df_ta = ta.stoch(high=df_stock['2. high'],
low=df_stock['3. low'],
close=df_stock['4. close'],
k=ns_parser.n_fastkperiod,
d=ns_parser.n_slowdperiod,
smooth_k=ns_parser.n_slowkperiod,
offset=ns_parser.n_offset).dropna()
plt.subplot(211)
plt.plot(df_stock.index, df_stock['4. close'].values, 'k', lw=2)
plt.title(
f"Stochastic Relative Strength Index (STOCH RSI) on {s_ticker}"
)
plt.xlim(df_stock.index[0], df_stock.index[-1])
plt.ylabel(f'Share Price ($)')
plt.grid(b=True, which='major', color='#666666', linestyle='-')
plt.minorticks_on()
plt.grid(b=True,
which='minor',
color='#999999',
linestyle='-',
alpha=0.2)
plt.subplot(212)
plt.plot(df_ta.index, df_ta.iloc[:, 0].values, 'k', lw=2)
plt.plot(df_ta.index, df_ta.iloc[:, 1].values, 'b', lw=2, ls='--')
plt.xlim(df_stock.index[0], df_stock.index[-1])
plt.axhspan(80, 100, facecolor='r', alpha=0.2)
plt.axhspan(0, 20, facecolor='g', alpha=0.2)
plt.axhline(80, linewidth=3, color='r', ls='--')
plt.axhline(20, linewidth=3, color='g', ls='--')
plt.legend([f'%K {df_ta.columns[0]}', f'%D {df_ta.columns[1]}'])
plt.xlabel('Time')
plt.grid(b=True, which='major', color='#666666', linestyle='-')
plt.minorticks_on()
plt.grid(b=True,
which='minor',
color='#999999',
linestyle='-',
alpha=0.2)
plt.ylim([0, 100])
plt.gca().twinx()
plt.ylim(plt.gca().get_ylim())
plt.yticks([.1, .9], ('OVERSOLD', 'OVERBOUGHT'))
plt.show()
print("")
except:
print("")
# %% pycharm={"is_executing": false}
#from talib import STOCH
import pandas_ta as ta #https://github.com/twopirllc/pandas-ta
#Recommended stochastics: [fk, sk, sd], [5,3,3], [21,7,7], [21,14,14]
fastk_parameter = [13, 5, 21, 21, 3]
slowk_parameter = [3, 3, 7, 14, 14]
slowd_parameter = [8, 3, 7, 14, 14]
stoch_features = pd.DataFrame(index=features.index)
for fk, sd, sk in zip(fastk_parameter, slowk_parameter, slowd_parameter):
print("Parameter: fastk={}, slowk={}, slowd={}".format(fk, sk, sd))
df=ta.stoch(high, low, close, fast_k=fk, slow_k=sk, slow_d=sd)
#print(df.columns)
#print(pd.Series(df['STOCH_' + str(sk)], name='Stoch_Sk' + str(fk)+str(sk)+str(sd)))
stoch_features = stoch_features.join(pd.Series(df['STOCH_' + str(sk)], name='Stoch_Sk' + str(fk)+str(sk)+str(sd)))
stoch_features = stoch_features.join(pd.Series(df['STOCH_' + str(sd)], name='Stoch_Sd' + str(fk)+str(sk)+str(sd)))
display(stoch_features.head(50))
print("Number of features: {}".format(stoch_features.shape))
plt.figure(num=None, figsize=(10, 7), dpi=80, facecolor='w', edgecolor='k')
plt.subplot(311)
plt.plot(source_cut['Date'][0:100],source_cut['Close'][0:100])
plt.title("Close")
plt.subplot(312)