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