def analyze_macd(self, historial_data, hot_thresh=None, cold_thresh=None): """Performs a macd analysis on the historical data Args: historial_data (list): A matrix of historical OHCLV data. hot_thresh (float, optional): Defaults to None. The threshold at which this might be good to purchase. cold_thresh (float, optional): Defaults to None. The threshold at which this might be good to sell. Returns: dict: A dictionary containing a tuple of indicator values and booleans for buy / sell indication. """ dataframe = self.__convert_to_dataframe(historial_data) macd_value = abstract.MACD(dataframe).iloc[-1, 0] macd_data = { 'values': (macd_value, ), 'is_hot': False, 'is_cold': False } return macd_data
def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame: macd = ta.MACD(dataframe) dataframe['maShort'] = ta.MA(dataframe, timeperiod=50) dataframe['maMedium'] = ta.MA(dataframe, timeperiod=200) return dataframe
def evaluate_macd_cross_over(self, prefix="macd_crossover", impact_buy=2, impact_sell=2): """ evaluates the MACD if we should buy or sale based on a crossover :param dataframe: :return: """ self._weights(impact_buy, impact_sell) dataframe = self.dataframe macd = ta.MACD(dataframe) dataframe['macd'] = macd['macd'] dataframe['macdsignal'] = macd['macdsignal'] dataframe['macdhist'] = macd['macdhist'] dataframe.loc[( crossed_above(dataframe['macdsignal'], dataframe['macd'])), 'sell_{}'.format(prefix)] = (1 * impact_sell) dataframe.loc[( crossed_above(dataframe['macd'], dataframe['macdsignal'])), 'buy_{}'.format(prefix)] = (1 * impact_buy) return dataframe
def populate_indicators(self, dataframe: DataFrame) -> DataFrame: dataframe['ema_high'] = ta.EMA(dataframe, timeperiod=5, price='high') dataframe['ema_close'] = ta.EMA(dataframe, timeperiod=5, price='close') dataframe['ema_low'] = ta.EMA(dataframe, timeperiod=5, price='low') stoch_fast = ta.STOCHF(dataframe, 5.0, 3.0, 0.0, 3.0, 0.0) dataframe['fastd'] = stoch_fast['fastd'] dataframe['fastk'] = stoch_fast['fastk'] dataframe['adx'] = ta.ADX(dataframe) dataframe['cci'] = ta.CCI(dataframe, timeperiod=20) dataframe['rsi'] = ta.RSI(dataframe, timeperiod=14) dataframe['mfi'] = ta.MFI(dataframe) # required for graphing bollinger = qtpylib.bollinger_bands(dataframe['close'], window=20, stds=2) dataframe['bb_lowerband'] = bollinger['lower'] dataframe['bb_upperband'] = bollinger['upper'] dataframe['bb_middleband'] = bollinger['mid'] macd = ta.MACD(dataframe) dataframe['macd'] = macd['macd'] dataframe['macdsignal'] = macd['macdsignal'] dataframe['macdhist'] = macd['macdhist'] dataframe['cci'] = ta.CCI(dataframe) return dataframe
def evaluate_macd_cross_over(self, prefix="macd_crossover", impact_buy=2, impact_sell=2): """ evaluates the MACD if we should buy or sale based on a crossover :param dataframe: :param prefix: :return: """ self._weights(impact_buy, impact_sell) dataframe = self.dataframe macd = ta.MACD(dataframe) dataframe["macd"] = macd["macd"] dataframe["macdsignal"] = macd["macdsignal"] dataframe["macdhist"] = macd["macdhist"] dataframe.loc[( crossed_above(dataframe["macdsignal"], dataframe["macd"])), f"sell_{prefix}"] = (1 * impact_sell) dataframe.loc[( crossed_above(dataframe["macd"], dataframe["macdsignal"])), f"buy_{prefix}"] = (1 * impact_buy) return dataframe
def evaluate_macd(self, prefix="macd", impact_buy=1, impact_sell=1): """ evaluates the MACD if we should buy or sale :param dataframe: :param prefix: :return: """ self._weights(impact_buy, impact_sell) dataframe = self.dataframe macd = ta.MACD(dataframe) dataframe["macd"] = macd["macd"] dataframe["macdsignal"] = macd["macdsignal"] dataframe["macdhist"] = macd["macdhist"] # macd < macds & macd < 0 == sell dataframe.loc[((dataframe["macd"] < dataframe["macdsignal"]) & (dataframe["macd"] < 0)), f"sell_{prefix}", ] = impact_sell # macd > macds & macd > 0 == buy dataframe.loc[((dataframe["macd"] > dataframe["macdsignal"]) & (dataframe["macd"] > 0)), f"buy_{prefix}", ] = impact_buy return dataframe
def analyze(self, historical_data, hot_thresh=None, cold_thresh=None, all_data=False): """Performs a macd analysis on the historical data Args: historical_data (list): A matrix of historical OHCLV data. hot_thresh (float, optional): Defaults to None. The threshold at which this might be good to purchase. cold_thresh (float, optional): Defaults to None. The threshold at which this might be good to sell. all_data (bool, optional): Defaults to False. If True, we return the MACD associated with each data point in our historical dataset. Otherwise just return the last one. Returns: dict: A dictionary containing a tuple of indicator values and booleans for buy / sell indication. """ dataframe = self.convert_to_dataframe(historical_data) macd_values = abstract.MACD(dataframe).iloc[:, 0] analyzed_data = [(value, ) for value in macd_values] return self.analyze_results(analyzed_data, is_hot=lambda v: v > hot_thresh if hot_thresh else False, is_cold=lambda v: v < cold_thresh if cold_thresh else False, all_data=all_data)
def analyze(self, historical_data, signal=['macd'], hot_thresh=None, cold_thresh=None): """Performs a macd analysis on the historical data Args: historical_data (list): A matrix of historical OHCLV data. signal (list, optional): Defaults to macd. The indicator line to check hot/cold against. hot_thresh (float, optional): Defaults to None. The threshold at which this might be good to purchase. cold_thresh (float, optional): Defaults to None. The threshold at which this might be good to sell. Returns: pandas.DataFrame: A dataframe containing the indicators and hot/cold values. """ dataframe = self.convert_to_dataframe(historical_data) macd_values = abstract.MACD(dataframe).iloc[:] macd_values.dropna(how='all', inplace=True) if macd_values[signal[0]].shape[0]: macd_values['is_hot'] = macd_values[signal[0]] > hot_thresh macd_values['is_cold'] = macd_values[signal[0]] < cold_thresh return macd_values
def evaluate_macd(self, prefix="macd", impact_buy=1, impact_sell=1): """ evaluates the MACD if we should buy or sale :param dataframe: :return: """ self._weights(impact_buy, impact_sell) dataframe = self.dataframe macd = ta.MACD(dataframe) dataframe['macd'] = macd['macd'] dataframe['macdsignal'] = macd['macdsignal'] dataframe['macdhist'] = macd['macdhist'] # macd < macds & macd < 0 == sell dataframe.loc[((dataframe['macd'] < dataframe['macdsignal']) & (dataframe['macd'] < 0)), 'sell_{}'.format(prefix)] = (1 * impact_sell) # macd > macds & macd > 0 == buy dataframe.loc[((dataframe['macd'] > dataframe['macdsignal']) & (dataframe['macd'] > 0)), 'buy_{}'.format(prefix)] = (1 * impact_buy) return dataframe
def populate_indicators(self, dataframe: DataFrame) -> DataFrame: macd = ta.MACD(dataframe) dataframe['maShort'] = ta.EMA(dataframe, timeperiod=8) dataframe['maMedium'] = ta.EMA(dataframe, timeperiod=21) 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 populate_indicators(dataframe: DataFrame) -> DataFrame: """ Adds several different TA indicators to the given DataFrame """ dataframe['sar'] = ta.SAR(dataframe) dataframe['adx'] = ta.ADX(dataframe) stoch = ta.STOCHF(dataframe) dataframe['fastd'] = stoch['fastd'] dataframe['fastk'] = stoch['fastk'] dataframe['blower'] = ta.BBANDS(dataframe, nbdevup=2, nbdevdn=2)['lowerband'] dataframe['sma'] = ta.SMA(dataframe, timeperiod=40) dataframe['tema'] = ta.TEMA(dataframe, timeperiod=9) dataframe['mfi'] = ta.MFI(dataframe) dataframe['cci'] = ta.CCI(dataframe) dataframe['rsi'] = ta.RSI(dataframe) dataframe['mom'] = ta.MOM(dataframe) dataframe['ema5'] = ta.EMA(dataframe, timeperiod=5) dataframe['ema10'] = ta.EMA(dataframe, timeperiod=10) dataframe['ema50'] = ta.EMA(dataframe, timeperiod=50) dataframe['ema100'] = ta.EMA(dataframe, timeperiod=100) dataframe['ao'] = awesome_oscillator(dataframe) macd = ta.MACD(dataframe) dataframe['macd'] = macd['macd'] dataframe['macdsignal'] = macd['macdsignal'] dataframe['macdhist'] = macd['macdhist'] return dataframe
def populate_indicators(dataframe: DataFrame, metadata: dict) -> DataFrame: """ Add several indicators needed for buy and sell strategies defined below. """ # ADX dataframe['adx'] = ta.ADX(dataframe) # MACD macd = ta.MACD(dataframe) dataframe['macd'] = macd['macd'] dataframe['macdsignal'] = macd['macdsignal'] # MFI dataframe['mfi'] = ta.MFI(dataframe) # RSI dataframe['rsi'] = ta.RSI(dataframe) # Stochastic Fast stoch_fast = ta.STOCHF(dataframe) dataframe['fastd'] = stoch_fast['fastd'] # Minus-DI dataframe['minus_di'] = ta.MINUS_DI(dataframe) # Bollinger bands bollinger = qtpylib.bollinger_bands(qtpylib.typical_price(dataframe), window=20, stds=2) dataframe['bb_lowerband'] = bollinger['lower'] dataframe['bb_upperband'] = bollinger['upper'] # SAR dataframe['sar'] = ta.SAR(dataframe) return dataframe
def do_populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame: """ Adds multiple TA indicators to MoniGoMani's DataFrame per pair. Should be called with 'informative_pair' (1h candles) during backtesting/hyperopting with TimeFrame-Zoom! Performance Note: For the best performance be frugal on the number of indicators you are using. Only add in indicators that you are using in your weighted signal configuration for MoniGoMani, otherwise you will waste your memory and CPU usage. :param dataframe: (DataFrame) DataFrame with data from the exchange :param metadata: (dict) Additional information, like the currently traded pair :return DataFrame: DataFrame for MoniGoMani with all mandatory indicator data populated """ # Momentum Indicators (timeperiod is expressed in candles) # ------------------- # Parabolic SAR dataframe['sar'] = ta.SAR(dataframe) # Stochastic Slow stoch = ta.STOCH(dataframe) dataframe['slowk'] = stoch['slowk'] # MACD - Moving Average Convergence Divergence macd = ta.MACD(dataframe) dataframe['macd'] = macd[ 'macd'] # MACD - Blue TradingView Line (Bullish if on top) dataframe['macdsignal'] = macd[ 'macdsignal'] # Signal - Orange TradingView Line (Bearish if on top) # MFI - Money Flow Index (Under bought / Over sold & Over bought / Under sold / volume Indicator) dataframe['mfi'] = ta.MFI(dataframe) # Overlap Studies # --------------- # Bollinger Bands bollinger = qtpylib.bollinger_bands(qtpylib.typical_price(dataframe), window=20, stds=2) dataframe['bb_middleband'] = bollinger['mid'] # SMA's & EMA's are trend following tools (Should not be used when line goes sideways) # SMA - Simple Moving Average (Moves slower compared to EMA, price trend over X periods) dataframe['sma9'] = ta.SMA(dataframe, timeperiod=9) dataframe['sma50'] = ta.SMA(dataframe, timeperiod=50) dataframe['sma200'] = ta.SMA(dataframe, timeperiod=200) # TEMA - Triple Exponential Moving Average dataframe['tema'] = ta.TEMA(dataframe, timeperiod=9) # Volume Indicators # ----------------- # Rolling VWAP - Volume Weighted Average Price dataframe['rolling_vwap'] = qtpylib.rolling_vwap(dataframe) return dataframe
def analyze_sl(self, historical_data, hot_thresh=None, cold_thresh=None, all_data=False): """Performs a macd analysis on the historical data using signal line for alerting Args: historical_data (list): A matrix of historical OHCLV data. hot_thresh (float, optional): Defaults to None. The threshold at which this might be good to purchase. cold_thresh (float, optional): Defaults to None. The threshold at which this might be good to sell. all_data (bool, optional): Defaults to False. If True, we return the MACD associated with each data point in our historical dataset. Otherwise just return the last one. Returns: dict: A dictionary containing a tuple of indicator values and booleans for buy / sell indication. """ dataframe = self.convert_to_dataframe(historical_data) macd_values = abstract.MACD(dataframe).iloc[:] # List of 2-tuples containing the ema value and closing price respectively analyzed_data = [(r[1]['macdsignal'], r[1]['macd']) for r in macd_values.iterrows()] return self.analyze_results(analyzed_data, is_hot=lambda s, v: s < v if hot_thresh else False, is_cold=lambda s, v: s > v if cold_thresh else False, all_data=all_data)
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) return dataframe
def populate_indicators(self, dataframe: DataFrame) -> DataFrame: ################################################################################## # buy and sell indicators 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'] macd = ta.MACD(dataframe) dataframe['macd'] = macd['macd'] dataframe['macdsignal'] = macd['macdsignal'] dataframe['macdhist'] = macd['macdhist'] # dataframe['cci'] = ta.CCI(dataframe) # dataframe['mfi'] = ta.MFI(dataframe) # dataframe['rsi'] = ta.RSI(dataframe, timeperiod=7) # dataframe['canbuy'] = np.NaN # dataframe['canbuy2'] = np.NaN # dataframe.loc[dataframe.close.rolling(49).min() <= 1.1 * dataframe.close, 'canbuy'] == 1 # dataframe.loc[dataframe.close.rolling(600).max() < 1.2 * dataframe.close, 'canbuy'] = 1 # dataframe.loc[dataframe.close.rolling(600).max() * 0.8 > dataframe.close, 'canbuy2'] = 1 ################################################################################## # required for graphing bollinger = qtpylib.bollinger_bands(dataframe['close'], window=20, stds=2) dataframe['bb_lowerband'] = bollinger['lower'] dataframe['bb_upperband'] = bollinger['upper'] dataframe['bb_middleband'] = bollinger['mid'] return dataframe
def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame: macd = ta.MACD(dataframe) dataframe['macd'] = macd['macd'] dataframe['macdsignal'] = macd['macdsignal'] dataframe['macdhist'] = macd['macdhist'] return dataframe
def cal_macd(self, fast=12, slow=26, signal=9): macd, macdsignal, macdhist = ta.MACD(self.close, fastperiod=fast, slowperiod=slow, signalperiod=signal) self.analysis_data['macd'] = macd self.analysis_data['macdsignal'] = macdsignal self.analysis_data['macdhist'] = macdhist
def generate_indicators(dataset, timeperiod=5, generate_target=True, reset_index=False): # To avoid changes from original dataset df = pd.DataFrame(dataset).copy() # To prevent index from being Date if (reset_index): df = df.reset_index() df.columns = df.columns.str.lower() # check the given dataset has necessary_columns __check_columns(df) df = df[necessary_columns] # df_indicators has all columns except date, this is for talib to produces other indicators df_indicators = df.iloc[:, 1:] # Produce other indicators RSI = abstract.RSI(df_indicators.close, timeperiod) RSI = pd.DataFrame({'RSI': RSI}) MOM = abstract.MOM(df_indicators.close, timeperiod) MOM = pd.DataFrame({'MOM': MOM}) KD = abstract.STOCH(df_indicators) KD = pd.DataFrame(KD) # KD has slowd and slowk MACD = abstract.MACD(df_indicators) MACD = pd.DataFrame(MACD) # MACD has its own column names ADX = abstract.ADX(df_indicators) ADX = pd.DataFrame({'ADX': ADX}) SMA = abstract.SMA(df_indicators.close) SMA = pd.DataFrame({'SMA': SMA}) upper, middle, lower = talib.BBANDS(df_indicators.close, matype=MA_Type.T3) bb_df = pd.DataFrame({ \ 'upper_bb' : upper, 'middel_bb' : middle, 'lower_bb' : lower}) # Combine all metrix frames = [df, RSI, MOM, KD, MACD, ADX, SMA, bb_df] combined = pd.concat(frames, axis=1) if (generate_target): target_name = 'next_' + str(timeperiod) + 'day_trend' combined[target_name] = np.where( combined.close.shift(-timeperiod) > combined.close, 1, 0) return combined
def populate_indicators(dataframe: DataFrame) -> DataFrame: """ Adds several different TA indicators to the given DataFrame """ # Log the dataframe dataframe.to_csv("dataframe.csv", sep='\t') #Determine Trend dataframe = indicators.TREND(dataframe) #Exponential Moving Average dataframe['ema'] = ta.EMA(dataframe, timeperiod=33) #Parabolic SAR dataframe['sar'] = ta.SAR(dataframe, 0.02, 0.22) #Average Directional Movement Index dataframe['adx'] = ta.ADX(dataframe) #MACD macd = ta.MACD(dataframe) dataframe['macd'] = macd['macd'] dataframe['macds'] = macd['macdsignal'] dataframe['macdh'] = macd['macdhist'] #Relative Strength Index dataframe['rsi'] = ta.RSI(dataframe, 14) dataframe = indicators.RSI(dataframe) #Absolute Price Oscillator dataframe['apo'] = ta.APO(dataframe, fastperiod=12, slowperiod=26, matype=0) #Momentum dataframe['mom'] = ta.MOM(dataframe, 10) #Bollinger Bands dataframe = indicators.BBANDS(20, dataframe, 2) # Stochcastic dataframe['K'] = indicators.STOK(dataframe, 14) dataframe['D'] = indicators.STOD(dataframe, 14) dataframe = indicators.STOCH(dataframe) # if Counter.counter < 30: # print(dataframe) # print (macd) # print (dataframe ['adx']) # Counter.counter = Counter.counter + 1 # else: # exit() return dataframe
def populate_indicators(self, dataframe: DataFrame) -> DataFrame: macd = ta.MACD(dataframe) dataframe['macd'] = macd['macd'] dataframe['macdsignal'] = macd['macdsignal'] dataframe['macdhist'] = macd['macdhist'] dataframe['cci'] = ta.CCI(dataframe) return dataframe
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 populate_indicators(self, dataframe: DataFrame) -> DataFrame: dataframe['adx'] = ta.ADX(dataframe, timeperiod=14) dataframe['ao'] = qtpylib.awesome_oscillator(dataframe) macd = ta.MACD(dataframe) dataframe['macd'] = macd['macd'] dataframe['macdsignal'] = macd['macdsignal'] dataframe['macdhist'] = macd['macdhist'] return dataframe
def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame: macd = ta.MACD(dataframe) dataframe['macd'] = macd['macd'] dataframe['macdsignal'] = macd['macdsignal'] dataframe['macdhist'] = macd['macdhist'] dataframe['ema100'] = ta.EMA(dataframe, timeperiod=100) return dataframe
def populate_indicators(dataframe: DataFrame, metadata: dict) -> DataFrame: dataframe['ema200'] = ta.EMA(dataframe, timeperiod=200) macd = ta.MACD(dataframe, fastperiod=24, slowperiod=56, signalperiod=6) dataframe['macd'] = macd['macd'] dataframe['macdsignal'] = macd['macdsignal'] dataframe['macdhist'] = macd['macdhist'] dataframe['rsi'] = ta.RSI(dataframe, timeperiod=14) dataframe['sell-rsi'] = ta.RSI(dataframe, timeperiod=14) return dataframe
def MACD(ohlcv, kw): """ :return Moving Average Convergence/Divergence (macd, macdsignal, macdhist =) """ params = {'fastperiod': 12, 'slowperiod': 26, 'signalperiod': 9} fastperiod, slowperiod, signalperiod = _get_params(kw, params, ['fastperiod', 'slowperiod', 'signalperiod']) result = talib.MACD(ohlcv, fastperiod, slowperiod, signalperiod) return { 'macd': result[0], 'macdsignal': result[1], 'macdhist': result[2] }
def populate_indicators(dataframe: DataFrame, metadata: dict) -> DataFrame: macd = ta.MACD(dataframe) dataframe["macd"] = macd["macd"] dataframe["macdsignal"] = macd["macdsignal"] for cciTime in cciTimeRange: cciName = "cci-" + str(cciTime) dataframe[cciName] = ta.CCI(dataframe, timeperiod=cciTime) return dataframe
def technical_index(self): df = self.max_min_price() df2 = self.institutional_investors() df['RSI'] = abstract.RSI(df) / 100 df['CMO'] =(abstract.CMO(df)+100) / (2 *100) df['MACD'] =(abstract.MACD(df)['macd']+abstract.MACD(df)['macd'].max()) / (2 *abstract.MACD(df)['macd'].max()) df['WILLR'] =(abstract.WILLR(df)+100) / (2 *100) df['WMA'] =abstract.WMA(df) / abstract.WMA(df).max() df['PPO'] =(abstract.PPO(df)+abstract.PPO(df).max()) / (2 *abstract.PPO(df).max()) df['EMA'] =abstract.EMA(df) / abstract.EMA(df).max() df['ROC'] =(abstract.ROC(df)+abstract.ROC(df).max()) / (2 *abstract.ROC(df).max()) df['SMA'] =abstract.SMA(df) / abstract.SMA(df).max() df['TEMA'] =abstract.TEMA(df) / abstract.TEMA(df).max() df['CCI'] =(abstract.CCI(df)+abstract.CCI(df).max()) / (2 *abstract.CCI(df).max()) df['investment_trust'] = (df2['investment_trust'] + df2['investment_trust'].max()) / (2*df2['investment_trust'].max()) df['foreign_investor'] = (df2['foreign_investor'] + df2['foreign_investor'].max()) / (2*df2['foreign_investor'].max()) df = df.drop(columns=['volume', 'open', 'high', 'low', 'close', 'close_max', 'close_min']) df = df.dropna() return df
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')