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 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 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 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 indicators(func_name, ohlcv, *args, **kwargs):
"""
获取单个股票期间talib函数指标
参数
----
func_name:str
talib函数名称
ohlcv:pd.DataFrame
以时间为Index，ohlcv五列数据框
args:func可接受的参数
kwargs:func可接受的键值对参数
返回
----
如果指标为单列，返回pd.Series
否则返回pd.DataFrame
"""
func = abstract.Function(func_name, ohlcv, *args, **kwargs)
return func.outputs
def enrichTalibValues(inputDict, features, result) :
headers=''
for aType in features:
for func in talib.get_function_groups()[aType]:
pf = abstract.Function(func)
try:
pf.input_arrays = inputDict
pf.run()
outputs = pf.outputs
if isinstance(outputs, list):
for anItem , name in zip(outputs, pf.output_names):
result = numpy.hstack((result, anItem.reshape(anItem.size,1)))
headers = ','.join([headers, name])
else:
result = numpy.hstack((result, outputs.reshape(outputs.size,1)))
headers = ','.join([headers,func])
except:
print
return result, headers
def CDL3LINESTRIKE(inputs, prices: list or None = None):
"""
{'name': 'CDL3LINESTRIKE',
'group': 'Pattern Recognition',
'display_name': 'Three-Line Strike ',
'function_flags': ['Output is a candlestick'],
'input_names': OrderedDict([('prices', ['open', 'high', 'low', 'close'])]),
'parameters': OrderedDict(),
'output_flags': OrderedDict([('integer', ['Line'])]),
'output_names': ['integer']}
:return:
"""
if prices is None:
prices = ['open', 'high', 'low', 'close']
indicator = abstract.Function('CDL3LINESTRIKE')
if not utils.check(inputs, prices):
raise ValueError('')
return indicator(inputs)
def STOCH(inputs,
fastk_period: int = 5,
slowk_period: int = 3,
slowk_matype: MA_Type = MA_Type.SMA,
slowd_period: int = 3,
slowd_matype: MA_Type = MA_Type.SMA,
prices: list or None = None):
"""
{'name': 'STOCH',
'group': 'Momentum Indicators',
'display_name': 'Stochastic',
'function_flags': None,
'input_names': OrderedDict([('prices', ['high', 'low', 'close'])]),
'parameters': OrderedDict([('fastk_period', 5),
('slowk_period', 3),
('slowk_matype', 0),
('slowd_period', 3),
('slowd_matype', 0)]),
'output_flags': OrderedDict([('slowk', ['Dashed Line']),
('slowd', ['Dashed Line'])]),
'output_names': ['slowk', 'slowd']}
:param inputs:
:param fastk_period:
:param slowk_period:
:param slowk_matype:
:param slowd_period:
:param slowd_matype:
:param prices:
:return:
"""
if prices is None:
prices = ['high', 'low', 'close']
indicator = abstract.Function('STOCH')
if not utils.check(inputs, prices):
raise ValueError('')
return indicator(inputs,
fastk_period=fastk_period,
slowk_period=slowk_period,
slowk_matype=slowk_matype.value,
slowd_period=slowd_period,
slowd_matype=slowd_matype.value,
prices=prices)
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 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 ROCR100(inputs, period: int = 10, price_type: str = 'close'):
"""
{'name': 'ROCR100',
'group': 'Momentum Indicators',
'display_name': 'Rate of change ratio 100 scale: (price/prevPrice)*100',
'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('ROCR100')
if not utils.check(inputs, [price_type]):
raise ValueError('')
return indicator(inputs, timeperiod=period, price=price_type)
def LINEARREG(
inputs,
timeperiod: int = 14,
price_type='close',
):
"""
{'name': 'LINEARREG',
'group': 'Statistic Functions',
'display_name': 'Linear Regression',
'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')
if not utils.check(inputs, [price_type]):
raise ValueError('')
return indicator(inputs, timeperiod=timeperiod, price=price_type)
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 extract_tafeatures(df, d_period, start_time, end_time):
input_arrays = df
#print(input_arrays)
row = []
for func_name in selected_funcs:
#print func_name
abs_func = abstract.Function(func_name)
denom = input_arrays['close'].iloc[
-1] if func_name in normalizeClose else 1.0
result = abs_func(input_arrays).iloc[-1] / denom
if func_name in normalize360:
result /= 360.0
if func_name in normalize100:
result /= 100.0
#print(result)
if isinstance(result, pd.Series):
row.extend(result.values)
else:
row.append(result)
return pd.Series(row)
def add_technical_indicator(self):
"""
Adds technical indicators from TA-lib onto new columns of the OHLCV dataframe in self.df
Returns:
pandas dataframe of OHLCV dataframe with technical indicators and generated columns
"""
processed_indicator_list = []
for indicator in list(self.tech_indicator_parameter_map.keys()):
try:
params = self.tech_indicator_parameter_map.get(indicator)
talib_name = params.pop('talib_name')
except KeyError as err:
print(
f"tech_indicator {indicator} not added as it is not specified in parameter mapping, ",
err)
continue
try:
ta_hook = abstract.Function(talib_name)
new_features = ta_hook(self.df['ovr'], **params)
if type(new_features) is pd.Series:
self.df['ovr', indicator] = new_features
processed_indicator_list.append(indicator)
elif type(new_features) is pd.DataFrame:
for colname in list(new_features.columns):
modified_colname = indicator + "_" + colname
self.df.loc[:,
('ovr',
modified_colname)] = new_features[colname]
processed_indicator_list.append(modified_colname)
except Exception as err:
print(f'{indicator} does not exist or has wrong parameters, ',
err)
continue
return processed_indicator_list
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 CDLLONGLEGGEDDOJI(inputs, prices: list or None = None):
"""
{'name': 'CDLLONGLEGGEDDOJI',
'group': 'Pattern Recognition',
'display_name': 'Long Legged Doji',
'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:
:param prices:
:return:
"""
if prices is None:
prices = ['open', 'high', 'low', 'close']
indicator = abstract.Function('CDLLONGLEGGEDDOJI')
if not utils.check(inputs, prices):
raise ValueError('')
return indicator(inputs)
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)
def MACDFIX(inputs, signalperiod: int = 9, price_type: str = 'close'):
"""
{'name': 'MACDFIX',
'group': 'Momentum Indicators',
'display_name': 'Moving Average Convergence/Divergence Fix 12/26',
'function_flags': None,
'input_names': OrderedDict([('price', 'close')]),
'parameters': OrderedDict([('signalperiod', 9)]),
'output_flags': OrderedDict([('macd', ['Line']),
('macdsignal', ['Dashed Line']),
('macdhist', ['Histogram'])]),
'output_names': ['macd', 'macdsignal', 'macdhist']}
:param inputs:
:param signalperiod:
:param price_type:
:return:
"""
indicator = abstract.Function('MACDFIX')
if not utils.check(inputs, [price_type]):
raise ValueError('')
return indicator(inputs, signalperiod=signalperiod, price=price_type)
def OBV(inputs, prices=None):
"""
{'name': 'OBV',
'group': 'Volume Indicators',
'display_name': 'On Balance Volume',
'function_flags': None,
'input_names': OrderedDict([('price', 'close'), ('prices', ['volume'])]),
'parameters': OrderedDict(),
'output_flags': OrderedDict([('real', ['Line'])]),
'output_names': ['real']}
:param inputs:
:param prices:
:return:
"""
if prices is None:
prices = ['close', 'volume']
indicator = abstract.Function('OBV')
if not utils.check(inputs, prices):
raise ValueError('')
volume = inputs[prices[1]]
return indicator(inputs, volume, price=prices[0], prices=[prices[1]])
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 CDLMATHOLD(inputs, penetration: float = 0.5, prices: list or None = None):
"""
{'name': 'CDLMATHOLD',
'group': 'Pattern Recognition',
'display_name': 'Mat Hold',
'function_flags': ['Output is a candlestick'],
'input_names': OrderedDict([('prices', ['open', 'high', 'low', 'close'])]),
'parameters': OrderedDict([('penetration', 0.5)]),
'output_flags': OrderedDict([('integer', ['Line'])]),
'output_names': ['integer']}
:param inputs:
:param prices:
:return:
"""
if prices is None:
prices = ['open', 'high', 'low', 'close']
indicator = abstract.Function('CDLMATHOLD')
if not utils.check(inputs, prices):
raise ValueError('')
return indicator(inputs, penetration=penetration)
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 CDLXSIDEGAP3METHODS(inputs, prices: list or None = None):
"""
{'name': 'CDLXSIDEGAP3METHODS',
'group': 'Pattern Recognition',
'display_name': 'Upside/Downside Gap Three Methods',
'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:
:param prices:
:return:
"""
if prices is None:
prices = ['open', 'high', 'low', 'close']
indicator = abstract.Function('CDLXSIDEGAP3METHODS')
if not utils.check(inputs, prices):
raise ValueError('')
return indicator(inputs)
def CDLKICKINGBYLENGTH(inputs, prices: list or None = None):
"""
{'name': 'CDLKICKINGBYLENGTH',
'group': 'Pattern Recognition',
'display_name': 'Kicking - bull/bear determined by the longer marubozu',
'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:
:param prices:
:return:
"""
if prices is None:
prices = ['open', 'high', 'low', 'close']
indicator = abstract.Function('CDLKICKINGBYLENGTH')
if not utils.check(inputs, prices):
raise ValueError('')
return indicator(inputs)
def NATR(inputs, period: int = 14, prices: list or None = None):
"""
{'name': 'NATR',
'group': 'Volatility Indicators',
'display_name': 'Normalized 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']}
:param inputs:
:param period:
:param prices:
:return:
"""
if prices is None:
prices = ['high', 'low', 'close']
indicator = abstract.Function('NATR')
if not utils.check(inputs, prices):
raise ValueError('')
return indicator(inputs, timeperiod=period, prices=prices)
def MIDPRICE(inputs, period: int = 14, prices=None):
"""
{'name': 'MIDPRICE',
'group': 'Overlap Studies',
'display_name': 'Midpoint Price over period',
'function_flags': ['Output scale same as input'],
'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('MIDPRICE')
if not utils.check(inputs, prices):
raise ValueError('')
return indicator(inputs, timeperiod=period, prices=prices)
def BBANDS(inputs,
period: int = 5,
nbdevup: float = 2.0,
nbdevdn: float = 2.0,
matype: MA_Type = MA_Type.SMA,
price_type: str = 'close'):
"""
{'name': 'BBANDS',
'group': 'Overlap Studies',
'display_name': 'Bollinger Bands',
'function_flags': ['Output scale same as input'],
'input_names': OrderedDict([('price', 'close')]),
'parameters': OrderedDict([('timeperiod', 5),
('nbdevup', 2),
('nbdevdn', 2),
('matype', 0)]),
'output_flags': OrderedDict([('upperband',
['Values represent an upper limit']),
('middleband', ['Line']),
('lowerband', ['Values represent a lower limit'])]),
'output_names': ['upperband', 'middleband', 'lowerband']}
:param inputs:
:param period:
:param nbdevup:
:param nbdevdn:
:param matype:
:param price_type:
:return:
"""
indicator = abstract.Function('BBANDS')
if not utils.check(inputs, [price_type]):
raise ValueError('')
return indicator(inputs,
timeperiod=period,
nbdevup=nbdevup,
nbdevdn=nbdevdn,
matype=matype.value,
price=price_type)
def calculate_tech_indicators(data, tech_indicators):
"""
Calculates technical indicators, provided data as Dataframe and list of technical indicators.
List of supported technical indicators: http://mrjbq7.github.io/ta-lib/
@:return Dataframe with tech indicators
"""
tech_indicators = [
tech_indicators
] if not isinstance(tech_indicators, list) else tech_indicators
results = []
for tech_indicator in tech_indicators:
tech_indicator = tech_indicator.lower()
t_func = abstract.Function(tech_indicator)
t_data = t_func(data)
# Series to Data Frame
if isinstance(t_data, pd.Series):
t_data = pd.DataFrame({tech_indicator: t_data.values},
index=t_data.index)
results.append(t_data)
results = pd.concat(results, axis=1)
return results
def taReturnTwo(self, taName):
if taName == 'MAMA':
return
concat1 = []
concat2 = []
for i in range(self.THREE_DAY_TIME, len(self.nparray['open'])):
sliced = self.sliceDic(i - self.THREE_DAY_TIME, i)
ta = abstract.Function(taName)
ta.set_input_arrays(sliced)
orgData = ta(self.THREE_DAY_TIME // 3)
# print(orgData,'###')
normaled1 = self.normalization(orgData[0])
normaled2 = self.normalization(orgData[1])
try:
concat1.append(normaled1[-1].copy())
concat2.append(normaled2[-1].copy())
except TypeError:
concat1, concat2 = normaled1, normaled2
return
# print('taReturnTwo concat1:',concat1)
# print('taReturnTwo concat2:',concat2)
self.listMake(concat1, taName)
self.listMake(concat2, taName)
