def MAVP(inputs, periods: str = 'periods', minperiod=2, maxperiod=30, matype: MA_Type = MA_Type.SMA, price_type: str = 'close'): """ {'name': 'MAVP', 'group': 'Overlap Studies', 'display_name': 'Moving average with variable period', 'function_flags': ['Output scale same as input'], 'input_names': OrderedDict([('price', 'close'), ('periods', 'periods')]), 'parameters': OrderedDict([('minperiod', 2), ('maxperiod', 30), ('matype', 0)]), 'output_flags': OrderedDict([('real', ['Line'])]), 'output_names': ['real']} :param inputs: :param minperiod: :param maxperiod: :param matype: :param price_type: :return: """ indicator = abstract.Function('MAVP') if not utils.check(inputs, [price_type, periods]): raise ValueError('') return indicator(inputs, periods=periods, minperiod=minperiod, maxperiod=maxperiod, matype=matype.value, price=price_type)
def ADX(inputs, period=14, prices: list or None = None): """ https://www.investopedia.com/terms/a/adx.asp {'name': 'ADX', 'group': 'Momentum Indicators', 'display_name': 'Average Directional Movement Index', 'function_flags': ['Function has an unstable period'], 'input_names': OrderedDict([('prices', ['high', 'low', 'close'])]), 'parameters': OrderedDict([('timeperiod', 14)]), 'output_flags': OrderedDict([('real', ['Line'])]), 'output_names': ['real']} :param inputs: :param period: :param prices: :return: """ if prices is None: prices = ['high', 'low', 'close'] indicator = abstract.Function('ADX') if not utils.check(inputs, prices): raise ValueError('Expect {} in the inputs. But only {}'.format( str(prices), str(inputs.columns) if isinstance(inputs, pd.DataFrame) else inputs.keys())) return indicator(inputs, timeperiod=period, prices=prices)
def SAR(inputs, acceleration: float = 0.02, period: int = 14, prices=None): """ {'name': 'SAR', 'group': 'Overlap Studies', 'display_name': 'Parabolic SAR', 'function_flags': ['Output scale same as input'], 'input_names': OrderedDict([('prices', ['high', 'low'])]), 'parameters': OrderedDict([('acceleration', 0.02), ('maximum', 0.2)]), 'output_flags': OrderedDict([('real', ['Line'])]), 'output_names': ['real']} :param inputs: :param acceleration: :param period: :param prices: :return: """ if prices is None: prices = ['high', 'low'] indicator = abstract.Function('SAR') if not utils.check(inputs, prices): raise ValueError('') return indicator(inputs, acceleration=acceleration, timeperiod=period, prices=prices)
def ULTOSC(inputs, period1: int = 7, period2: int = 14, period3: int = 28, prices: list or None = None): """ {'name': 'ULTOSC', 'group': 'Momentum Indicators', 'display_name': 'Ultimate Oscillator', 'function_flags': None, 'input_names': OrderedDict([('prices', ['high', 'low', 'close'])]), 'parameters': OrderedDict([('timeperiod1', 7), ('timeperiod2', 14), ('timeperiod3', 28)]), 'output_flags': OrderedDict([('real', ['Line'])]), 'output_names': ['real']} :param inputs: :param period1: :param period2: :param period3: :param prices: :return: """ if prices is None: prices = ['high', 'low', 'close'] indicator = abstract.Function('ULTOSC') if not utils.check(inputs, prices): raise ValueError('') return indicator(inputs, timeperiod1=period1, timeperiod2=period2, timeperiod3=period3, prices=prices)
def STOCHF(inputs, fastk_period: int = 5, fastd_period: int = 3, fastd_matype: MA_Type = MA_Type.SMA, prices: list or None = None): """ {'name': 'STOCHF', 'group': 'Momentum Indicators', 'display_name': 'Stochastic Fast', 'function_flags': None, 'input_names': OrderedDict([('prices', ['high', 'low', 'close'])]), 'parameters': OrderedDict([('fastk_period', 5), ('fastd_period', 3), ('fastd_matype', 0)]), 'output_flags': OrderedDict([('fastk', ['Line']), ('fastd', ['Line'])]), 'output_names': ['fastk', 'fastd']} :param inputs: :param fastk_period: :param fastd_period: :param fastd_matype: :param prices: :return: """ if prices is None: prices = ['high', 'low', 'close'] indicator = abstract.Function('STOCHF') if not utils.check(inputs, prices): raise ValueError('') return indicator(inputs, fastk_period=fastk_period, fastd_period=fastd_period, fastd_matype=fastd_matype.value, prices=prices)
def APO(inputs, fastperiod: int = 12, slowperiod: int = 26, matype: MA_Type = MA_Type.SMA, price_type: str = 'close'): """ {'name': 'APO', 'group': 'Momentum Indicators', 'display_name': 'Absolute Price Oscillator', 'function_flags': None, 'input_names': OrderedDict([('price', 'close')]), 'parameters': OrderedDict([('fastperiod', 12), ('slowperiod', 26), ('matype', 0)]), 'output_flags': OrderedDict([('real', ['Line'])]), 'output_names': ['real']} :param inputs: :param fastperiod: :param slowperiod: :param matype: :param price_type: :return: """ indicator = abstract.Function('APO') if not utils.check(inputs, [price_type]): raise ValueError('') return indicator(inputs, fastperiod=fastperiod, slowperiod=slowperiod, matype=matype.value, price=price_type)
def AROON(inputs, period=14, prices: list or None = None): """ {'name': 'AROON', 'group': 'Momentum Indicators', 'display_name': 'Aroon', 'function_flags': None, 'input_names': OrderedDict([('prices', ['high', 'low'])]), 'parameters': OrderedDict([('timeperiod', 14)]), 'output_flags': OrderedDict([('aroondown', ['Dashed Line']), ('aroonup', ['Line'])]), 'output_names': ['aroondown', 'aroonup']} :param inputs: :param period: :param prices: :return: ['aroondown', 'aroonup'] """ if prices is None: prices = ['high', 'low'] indicator = abstract.Function('AROON') if not utils.check(inputs, prices): raise ValueError('') return indicator(inputs, timeperiod=period, prices=prices)
def MAMA(inputs, fastlimit: int = 0.5, slowlimit: int = 0.05, price_type: str = 'close'): """ {'name': 'MAMA', 'group': 'Overlap Studies', 'display_name': 'MESA Adaptive Moving Average', 'function_flags': ['Output scale same as input', 'Function has an unstable period'], 'input_names': OrderedDict([('price', 'close')]), 'parameters': OrderedDict([('fastlimit', 0.5), ('slowlimit', 0.05)]), 'output_flags': OrderedDict([('mama', ['Line']), ('fama', ['Dashed Line'])]), 'output_names': ['mama', 'fama']} :param inputs: :param fastlimit: :param slowlimit: :param price_type: :return: """ indicator = abstract.Function('MAMA') if not utils.check(inputs, [price_type]): raise ValueError('') return indicator(inputs, fastlimit=fastlimit, slowlimit=slowlimit, price=price_type)
def MACD(inputs, fastperiod: int = 12, slowperiod: int = 26, signalperiod: int = 9, price_type: str = 'close'): """ {'name': 'MACD', 'group': 'Momentum Indicators', 'display_name': 'Moving Average Convergence/Divergence', 'function_flags': None, 'input_names': OrderedDict([('price', 'close')]), 'parameters': OrderedDict([('fastperiod', 12), ('slowperiod', 26), ('signalperiod', 9)]), 'output_flags': OrderedDict([('macd', ['Line']), ('macdsignal', ['Dashed Line']), ('macdhist', ['Histogram'])]), 'output_names': ['macd', 'macdsignal', 'macdhist']} :param inputs: :param fastperiod: :param slowperiod: :param signalperiod: :param price_type: :return: """ indicator = abstract.Function('MACD') if not utils.check(inputs, [price_type]): raise ValueError('') return indicator(inputs, fastperiod=fastperiod, slowperiod=slowperiod, signalperiod=signalperiod, price=price_type)
def ADOSC(inputs, fastperiod: int = 3, slowperiod: int = 10, prices=None): """ {'name': 'ADOSC', 'group': 'Volume Indicators', 'display_name': 'Chaikin A/D Oscillator', 'function_flags': None, 'input_names': OrderedDict([('prices', ['high', 'low', 'close', 'volume'])]), 'parameters': OrderedDict([('fastperiod', 3), ('slowperiod', 10)]), 'output_flags': OrderedDict([('real', ['Line'])]), 'output_names': ['real']} :param inputs: :param fastperiod: :param slowperiod: :param prices: :return: """ if prices is None: prices = ['high', 'low', 'close', 'volume'] indicator = abstract.Function('ADOSC') if not utils.check(inputs, prices): raise ValueError('') return indicator(inputs, fastperiod=fastperiod, slowperiod=slowperiod, prices=prices)
def STOCHRSI(inputs, period: int = 14, fastk_period: int = 5, fastd_period: int = 3, fastd_matype: MA_Type = MA_Type.SMA, price_type: str = 'close'): """ {'name': 'STOCHRSI', 'group': 'Momentum Indicators', 'display_name': 'Stochastic Relative Strength Index', 'function_flags': ['Function has an unstable period'], 'input_names': OrderedDict([('price', 'close')]), 'parameters': OrderedDict([('timeperiod', 14), ('fastk_period', 5), ('fastd_period', 3), ('fastd_matype', 0)]), 'output_flags': OrderedDict([('fastk', ['Line']), ('fastd', ['Line'])]), 'output_names': ['fastk', 'fastd']} :param inputs: :param period: :param fastk_period: :param fastd_period: :param fastd_matype: :param price_type: :return: """ indicator = abstract.Function('STOCHRSI') if not utils.check(inputs, [price_type]): raise ValueError('') return indicator(inputs, timeperiod=period, fastk_period=fastk_period, fastd_period=fastd_period, fastd_matype=fastd_matype.value, price=price_type)
def SAREXT(inputs, offsetonreverse: float = 0.0, accelerationinitlong=0.02, accelerationlong=0.02, accelerationmaxlong=0.2, accelerationinitshort=0.02, accelerationshort=0.02, accelerationmaxshort=0.2, prices=None): """ {'name': 'SAREXT', 'group': 'Overlap Studies', 'display_name': 'Parabolic SAR - Extended', 'function_flags': ['Output scale same as input'], 'input_names': OrderedDict([('prices', ['high', 'low'])]), 'parameters': OrderedDict([('startvalue', 0), ('offsetonreverse', 0), ('accelerationinitlong', 0.02), ('accelerationlong', 0.02), ('accelerationmaxlong', 0.2), ('accelerationinitshort', 0.02), ('accelerationshort', 0.02), ('accelerationmaxshort', 0.2)]), 'output_flags': OrderedDict([('real', ['Line'])]), 'output_names': ['real']} :param inputs: :param offsetonreverse: :param accelerationinitlong: :param accelerationlong: :param accelerationmaxlong: :param accelerationinitshort: :param accelerationshort: :param accelerationmaxshort: :param prices: :return: """ if prices is None: prices = ['high', 'low'] indicator = abstract.Function('SAREXT') if not utils.check(inputs, prices): raise ValueError('') return indicator(inputs, offsetonreverse=offsetonreverse, accelerationinitlong=accelerationinitlong, accelerationlong=accelerationlong, accelerationmaxlong=accelerationmaxlong, accelerationinitshort=accelerationinitshort, accelerationshort=accelerationshort, accelerationmaxshort=accelerationmaxshort, prices=prices)
def TSF(inputs, timeperiod: int = 14, price_type='close'): """ {'name': 'TSF', 'group': 'Statistic Functions', 'display_name': 'Time Series Forecast', 'function_flags': ['Output scale same as input'], 'input_names': OrderedDict([('price', 'close')]), 'parameters': OrderedDict([('timeperiod', 14)]), 'output_flags': OrderedDict([('real', ['Line'])]), 'output_names': ['real']} :return: """ indicator = abstract.Function('TSF') if not utils.check(inputs, [price_type]): raise ValueError('') return indicator(inputs, timeperiod=timeperiod, price=price_type)
def LINEARREG_INTERCEPT(inputs, timeperiod: int = 14, price_type='close'): """ {'name': 'LINEARREG_INTERCEPT', 'group': 'Statistic Functions', 'display_name': 'Linear Regression Intercept', 'function_flags': ['Output scale same as input'], 'input_names': OrderedDict([('price', 'close')]), 'parameters': OrderedDict([('timeperiod', 14)]), 'output_flags': OrderedDict([('real', ['Line'])]), 'output_names': ['real']} :return: """ indicator = abstract.Function('LINEARREG_INTERCEPT') if not utils.check(inputs, [price_type]): raise ValueError('') return indicator(inputs, timeperiod=timeperiod, price=price_type)
def MACDEXT(inputs, fastperiod: int = 12, fastmatype: MA_Type = MA_Type.SMA, slowperiod: int = 26, slowmatype: MA_Type = MA_Type.SMA, signalperiod: int = 9, signalmatype: MA_Type = MA_Type.SMA, price_type: str = 'close'): """ {'name': 'MACDEXT', 'group': 'Momentum Indicators', 'display_name': 'MACD with controllable MA type', 'function_flags': None, 'input_names': OrderedDict([('price', 'close')]), 'parameters': OrderedDict([('fastperiod', 12), ('fastmatype', 0), ('slowperiod', 26), ('slowmatype', 0), ('signalperiod', 9), ('signalmatype', 0)]), 'output_flags': OrderedDict([('macd', ['Line']), ('macdsignal', ['Dashed Line']), ('macdhist', ['Histogram'])]), 'output_names': ['macd', 'macdsignal', 'macdhist']} :param inputs: :param fastperiod: :param fastmatype: :param slowperiod: :param slowmatype: :param signalperiod: :param signalmatype: :param price_type: :return: """ indicator = abstract.Function('MACDEXT') if not utils.check(inputs, [price_type]): raise ValueError('') return indicator(inputs, fastperiod=fastperiod, fastmatype=fastmatype.value, slowperiod=slowperiod, slowmatype=slowmatype.value, signalperiod=signalperiod, signalmatype=signalmatype.value, price=price_type)
def CDL2CROWS(inputs, prices: list or None = None): """ {'name': 'CDL2CROWS', 'group': 'Pattern Recognition', 'display_name': 'Two Crows', 'function_flags': ['Output is a candlestick'], 'input_names': OrderedDict([('prices', ['open', 'high', 'low', 'close'])]), 'parameters': OrderedDict(), 'output_flags': OrderedDict([('integer', ['Line'])]), 'output_names': ['integer']} :param inputs: :return: """ if prices is None: prices = ['open', 'high', 'low', 'close'] indicator = abstract.Function('CDL2CROWS') if not utils.check(inputs, prices): raise ValueError('') return indicator(inputs)
def ATR(inputs, period: int = 14, prices=None): """ {'name': 'ATR', 'group': 'Volatility Indicators', 'display_name': 'Average True Range', 'function_flags': ['Function has an unstable period'], 'input_names': OrderedDict([('prices', ['high', 'low', 'close'])]), 'parameters': OrderedDict([('timeperiod', 14)]), 'output_flags': OrderedDict([('real', ['Line'])]), 'output_names': ['real']} :return: """ if prices is None: prices = ['high', 'low', 'close'] indicator = abstract.Function('ATR') if not utils.check(inputs, prices): raise ValueError('') return indicator(inputs, timeperiod=period, prices=prices)
def VAR(inputs, timeperiod: int = 5, nbdev: float = 1.0, price_type='close'): """ {'name': 'VAR', 'group': 'Statistic Functions', 'display_name': 'Variance', 'function_flags': None, 'input_names': OrderedDict([('price', 'close')]), 'parameters': OrderedDict([('timeperiod', 5), ('nbdev', 1)]), 'output_flags': OrderedDict([('real', ['Line'])]), 'output_names': ['real']} :return: """ indicator = abstract.Function('VAR') if not utils.check(inputs, [price_type]): raise ValueError('') return indicator(inputs, timeperiod=timeperiod, nbdev=nbdev, price=price_type)
def WMA(inputs, period: int = 30, price_type: str = 'close'): """ {'name': 'WMA', 'group': 'Overlap Studies', 'display_name': 'Weighted Moving Average', 'function_flags': ['Output scale same as input'], 'input_names': OrderedDict([('price', 'close')]), 'parameters': OrderedDict([('timeperiod', 30)]), 'output_flags': OrderedDict([('real', ['Line'])]), 'output_names': ['real']} :param inputs: :param period: :param price_type: :return: """ indicator = abstract.Function('WMA') if not utils.check(inputs, [price_type]): raise ValueError('') return indicator(inputs, timeperiod=period, price=price_type)
def HT_TRENDLINE(inputs, price_type: str = 'close'): """ {'name': 'HT_TRENDLINE', 'group': 'Overlap Studies', 'display_name': 'Hilbert Transform - Instantaneous Trendline', 'function_flags': ['Output scale same as input', 'Function has an unstable period'], 'input_names': OrderedDict([('price', 'close')]), 'parameters': OrderedDict(), 'output_flags': OrderedDict([('real', ['Line'])]), 'output_names': ['real']} :param inputs: :param price_type: :return: """ indicator = abstract.Function('HT_TRENDLINE') if not utils.check(inputs, [price_type]): raise ValueError('') return indicator(inputs, price=price_type)
def BETA(inputs, timeperiod: int = 5, price0='high', price1='low'): """ {'name': 'BETA', 'group': 'Statistic Functions', 'display_name': 'Beta', 'function_flags': None, 'input_names': OrderedDict([('price0', 'high'), ('price1', 'low')]), 'parameters': OrderedDict([('timeperiod', 5)]), 'output_flags': OrderedDict([('real', ['Line'])]), 'output_names': ['real']} :param inputs: :return: """ indicator = abstract.Function('BETA') if not utils.check(inputs, [price0, price1]): raise ValueError('') return indicator(inputs, timeperiod=timeperiod, price0=price0, price1=price1)
def TRIX(inputs, period: int = 30, price_type: str = 'close'): """ {'name': 'TRIX', 'group': 'Momentum Indicators', 'display_name': '1-day Rate-Of-Change (ROC) of a Triple Smooth EMA', 'function_flags': None, 'input_names': OrderedDict([('price', 'close')]), 'parameters': OrderedDict([('timeperiod', 30)]), 'output_flags': OrderedDict([('real', ['Line'])]), 'output_names': ['real']} :param inputs: :param period: :param price_type: :return: """ indicator = abstract.Function('TRIX') if not utils.check(inputs, [price_type]): raise ValueError('') return indicator(inputs, timeperiod=period, price=price_type)
def ROCP(inputs, period: int = 10, price_type: str = 'close'): """ {'name': 'ROCP', 'group': 'Momentum Indicators', 'display_name': 'Rate of change Percentage: (price-prevPrice)/prevPrice', 'function_flags': None, 'input_names': OrderedDict([('price', 'close')]), 'parameters': OrderedDict([('timeperiod', 10)]), 'output_flags': OrderedDict([('real', ['Line'])]), 'output_names': ['real']} :param inputs: :param period: :param price_type: :return: """ indicator = abstract.Function('ROCP') if not utils.check(inputs, [price_type]): raise ValueError('') return indicator(inputs, timeperiod=period, price=price_type)
def CORREL(inputs, timeperiod: int = 30, price0='high', price1='low'): """ {'name': 'CORREL', 'group': 'Statistic Functions', 'display_name': "Pearson's Correlation Coefficient (r)", 'function_flags': None, 'input_names': OrderedDict([('price0', 'high'), ('price1', 'low')]), 'parameters': OrderedDict([('timeperiod', 30)]), 'output_flags': OrderedDict([('real', ['Line'])]), 'output_names': ['real']} :return: """ indicator = abstract.Function('BETA') if not utils.check(inputs, [price0, price1]): raise ValueError('') return indicator(inputs, timeperiod=timeperiod, price0=price0, price1=price1)
def AD(inputs, prices=None): """ {'name': 'AD', 'group': 'Volume Indicators', 'display_name': 'Chaikin A/D Line', 'function_flags': None, 'input_names': OrderedDict([('prices', ['high', 'low', 'close', 'volume'])]), 'parameters': OrderedDict(), 'output_flags': OrderedDict([('real', ['Line'])]), 'output_names': ['real']} :param inputs: :param prices: :return: """ if prices is None: prices = ['high', 'low', 'close', 'volume'] indicator = abstract.Function('AD') if not utils.check(inputs, prices): raise ValueError('') return indicator(inputs, prices=prices)
def RSI(inputs, period: int = 14, price_type: str = 'close'): """ {'name': 'RSI', 'group': 'Momentum Indicators', 'display_name': 'Relative Strength Index', 'function_flags': ['Function has an unstable period'], 'input_names': OrderedDict([('price', 'close')]), 'parameters': OrderedDict([('timeperiod', 14)]), 'output_flags': OrderedDict([('real', ['Line'])]), 'output_names': ['real']} :param inputs: :param period: :param price_type: :return: """ indicator = abstract.Function('RSI') if not utils.check(inputs, [price_type]): raise ValueError('') return indicator(inputs, timeperiod=period, price=price_type)
def TRANGE(inputs, prices: list or None = None): """ {'name': 'TRANGE', 'group': 'Volatility Indicators', 'display_name': 'True Range', 'function_flags': None, 'input_names': OrderedDict([('prices', ['high', 'low', 'close'])]), 'parameters': OrderedDict(), 'output_flags': OrderedDict([('real', ['Line'])]), 'output_names': ['real']} :param inputs: :param prices: :return: """ if prices is None: prices = ['high', 'low', 'close'] indicator = abstract.Function('TRANGE') if not utils.check(inputs, prices): raise ValueError('') return indicator(inputs, prices=prices)
def BOP(inputs, prices: list or None = None): """ {'name': 'BOP', 'group': 'Momentum Indicators', 'display_name': 'Balance Of Power', 'function_flags': None, 'input_names': OrderedDict([('prices', ['open', 'high', 'low', 'close'])]), 'parameters': OrderedDict(), 'output_flags': OrderedDict([('real', ['Line'])]), 'output_names': ['real']} :param inputs: :param prices: :return: """ if prices is None: prices = ['open', 'high', 'low', 'close'] indicator = abstract.Function('BOP') if not utils.check(inputs, prices): raise ValueError('') return indicator(inputs, prices=prices)
def PLUS_DM(inputs, period: int = 14, prices: list or None = None): """ {'name': 'PLUS_DM', 'group': 'Momentum Indicators', 'display_name': 'Plus Directional Movement', 'function_flags': ['Function has an unstable period'], 'input_names': OrderedDict([('prices', ['high', 'low'])]), 'parameters': OrderedDict([('timeperiod', 14)]), 'output_flags': OrderedDict([('real', ['Line'])]), 'output_names': ['real']} :param inputs: :param period: :param prices: :return: """ if prices is None: prices = ['high', 'low'] indicator = abstract.Function('PLUS_DM') if not utils.check(inputs, prices): raise ValueError('') return indicator(inputs, timeperiod=period, prices=prices)
def CCI(inputs, period: int = 14, prices: list or None = None): """ {'name': 'CCI', 'group': 'Momentum Indicators', 'display_name': 'Commodity Channel Index', 'function_flags': None, 'input_names': OrderedDict([('prices', ['high', 'low', 'close'])]), 'parameters': OrderedDict([('timeperiod', 14)]), 'output_flags': OrderedDict([('real', ['Line'])]), 'output_names': ['real']} :param inputs: :param period: :param prices: :return: """ if prices is None: prices = ['high', 'low', 'close'] indicator = abstract.Function('CCI') if not utils.check(inputs, prices): raise ValueError('') return indicator(inputs, timeperiod=period, prices=prices)