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)