def add_volatility_indicators(data: pd.DataFrame) -> pd.DataFrame:
"""Adds the volatility indicators.
Parameters
----------
data : pd.DataFrame
A dataframe with daily stock values. Must include: open, high,
low, close and volume. It should also be sorted in a descending
manner.
Returns
-------
pd.DataFrame
The input dataframe with the indicators added.
"""
bb = BollingerBands(data['close'])
data.loc[:, 'bollinger_hband'] = bb.bollinger_hband()
data.loc[:, 'bollinger_hband_indicator'] = bb.bollinger_hband_indicator()
data.loc[:, 'bollinger_lband'] = bb.bollinger_lband()
data.loc[:, 'bollinger_lband_indicator'] = bb.bollinger_lband_indicator()
data.loc[:, 'bollinger_mavg'] = bb.bollinger_mavg()
data.loc[:, 'bollinger_pband'] = bb.bollinger_pband()
data.loc[:, 'bollinger_wband'] = bb.bollinger_wband()
return data
def add_volatility_ta(df: pd.DataFrame,
high: str,
low: str,
close: str,
fillna: bool = False,
colprefix: str = "") -> pd.DataFrame:
"""Add volatility technical analysis features to dataframe.
Args:
df (pandas.core.frame.DataFrame): Dataframe base.
high (str): Name of 'high' column.
low (str): Name of 'low' column.
close (str): Name of 'close' column.
fillna(bool): if True, fill nan values.
colprefix(str): Prefix column names inserted
Returns:
pandas.core.frame.DataFrame: Dataframe with new features.
"""
# Average True Range
df[f'{colprefix}volatility_atr'] = AverageTrueRange(
close=df[close], high=df[high], low=df[low], n=10,
fillna=fillna).average_true_range()
# Bollinger Bands
indicator_bb = BollingerBands(close=df[close], n=20, ndev=2, fillna=fillna)
df[f'{colprefix}volatility_bbm'] = indicator_bb.bollinger_mavg()
df[f'{colprefix}volatility_bbh'] = indicator_bb.bollinger_hband()
df[f'{colprefix}volatility_bbl'] = indicator_bb.bollinger_lband()
df[f'{colprefix}volatility_bbw'] = indicator_bb.bollinger_wband()
df[f'{colprefix}volatility_bbhi'] = indicator_bb.bollinger_hband_indicator(
)
df[f'{colprefix}volatility_bbli'] = indicator_bb.bollinger_lband_indicator(
)
# Keltner Channel
indicator_kc = KeltnerChannel(close=df[close],
high=df[high],
low=df[low],
n=10,
fillna=fillna)
df[f'{colprefix}volatility_kcc'] = indicator_kc.keltner_channel_central()
df[f'{colprefix}volatility_kch'] = indicator_kc.keltner_channel_hband()
df[f'{colprefix}volatility_kcl'] = indicator_kc.keltner_channel_lband()
df[f'{colprefix}volatility_kchi'] = indicator_kc.keltner_channel_hband_indicator(
)
df[f'{colprefix}volatility_kcli'] = indicator_kc.keltner_channel_lband_indicator(
)
# Donchian Channel
indicator_dc = DonchianChannel(close=df[close], n=20, fillna=fillna)
df[f'{colprefix}volatility_dcl'] = indicator_dc.donchian_channel_lband()
df[f'{colprefix}volatility_dch'] = indicator_dc.donchian_channel_hband()
df[f'{colprefix}volatility_dchi'] = indicator_dc.donchian_channel_hband_indicator(
)
df[f'{colprefix}volatility_dcli'] = indicator_dc.donchian_channel_lband_indicator(
)
return df
def _run(self):
# Bollinger Bands
bb_indicator = BollingerBands(close=self._close,
n=self._chan_period,
ndev=self._bol_band_std_dev,
fillna=self._fillna)
self._bb_hband = bb_indicator.bollinger_hband()
self._bb_lband = bb_indicator.bollinger_lband()
# Keltner Channel
kb_indicator = KeltnerChannel(high=self._high,
low=self._low,
close=self._close,
n=self._chan_period,
n_atr=self._kelt_std_dev,
fillna=self._fillna,
ov=False)
self._kb_hband = kb_indicator.keltner_channel_hband()
self._kb_lband = kb_indicator.keltner_channel_lband()
# Momentum Oscillator
smo_indicator = SMOIndicator(high=self._high,
low=self._low,
close=self._close,
n=self._mom_period,
fillna=self._fillna)
self._oscillator = smo_indicator.smo()
# Bar and Signal Colors
self._squeeze = bb_indicator.bollinger_wband(
) - kb_indicator.keltner_channel_wband()
self._squeeze = self._squeeze.ge(0).astype(int)
class TestBollingerBands(unittest.TestCase):
"""
https://school.stockcharts.com/doku.php?id=technical_indicators:bollinger_bands
"""
_filename = 'ta/tests/data/cs-bbands.csv'
def setUp(self):
self._df = pd.read_csv(self._filename, sep=',')
self._indicator = BollingerBands(close=self._df['Close'],
n=20,
ndev=2,
fillna=False)
def tearDown(self):
del (self._df)
def test_mavg(self):
target = 'MiddleBand'
result = self._indicator.bollinger_mavg()
pd.testing.assert_series_equal(self._df[target].tail(),
result.tail(),
check_names=False)
def test_hband(self):
target = 'HighBand'
result = self._indicator.bollinger_hband()
pd.testing.assert_series_equal(self._df[target].tail(),
result.tail(),
check_names=False)
def test_lband(self):
target = 'LowBand'
result = self._indicator.bollinger_lband()
pd.testing.assert_series_equal(self._df[target].tail(),
result.tail(),
check_names=False)
def test_wband(self):
target = 'WidthBand'
result = self._indicator.bollinger_wband()
pd.testing.assert_series_equal(self._df[target].tail(),
result.tail(),
check_names=False)
def test_hband_indicator(self):
target = 'CrossUp'
result = self._indicator.bollinger_hband_indicator()
pd.testing.assert_series_equal(self._df[target].tail(),
result.tail(),
check_names=False)
def test_lband_indicator(self):
target = 'CrossDown'
result = self._indicator.bollinger_lband_indicator()
pd.testing.assert_series_equal(self._df[target].tail(),
result.tail(),
check_names=False)
def bollinger_bands(df):
indicator_bb = BollingerBands(close=df["Close"])
df['bb_bbh'] = indicator_bb.bollinger_hband()
df['bb_bbl'] = indicator_bb.bollinger_lband()
df['bb_avg'] = indicator_bb.bollinger_mavg()
df['bb_bbh_ind'] = indicator_bb.bollinger_hband_indicator()
df['bb_bbl_ind'] = indicator_bb.bollinger_lband_indicator()
df['bb_pband'] = indicator_bb.bollinger_pband()
df['bb_wband'] = indicator_bb.bollinger_wband()
def transform_one(self, entity_id, df: pd.DataFrame) -> pd.DataFrame:
indicator_bb = BollingerBands(close=df["close"],
window=20,
window_dev=2)
# Add Bollinger Bands features
df["bb_bbm"] = indicator_bb.bollinger_mavg()
df["bb_bbh"] = indicator_bb.bollinger_hband()
df["bb_bbl"] = indicator_bb.bollinger_lband()
# Add Bollinger Band high indicator
df["bb_bbhi"] = indicator_bb.bollinger_hband_indicator()
# Add Bollinger Band low indicator
df["bb_bbli"] = indicator_bb.bollinger_lband_indicator()
# Add Width Size Bollinger Bands
df["bb_bbw"] = indicator_bb.bollinger_wband()
# Add Percentage Bollinger Bands
df["bb_bbp"] = indicator_bb.bollinger_pband()
return df
def add_volatility_ta(
df: pd.DataFrame,
high: str,
low: str,
close: str,
fillna: bool = False,
colprefix: str = "",
vectorized: bool = False,
) -> pd.DataFrame:
"""Add volatility technical analysis features to dataframe.
Args:
df (pandas.core.frame.DataFrame): Dataframe base.
high (str): Name of 'high' column.
low (str): Name of 'low' column.
close (str): Name of 'close' column.
fillna(bool): if True, fill nan values.
colprefix(str): Prefix column names inserted
vectorized(bool): if True, use only vectorized functions indicators
Returns:
pandas.core.frame.DataFrame: Dataframe with new features.
"""
# Bollinger Bands
indicator_bb = BollingerBands(close=df[close],
window=20,
window_dev=2,
fillna=fillna)
df[f"{colprefix}volatility_bbm"] = indicator_bb.bollinger_mavg()
df[f"{colprefix}volatility_bbh"] = indicator_bb.bollinger_hband()
df[f"{colprefix}volatility_bbl"] = indicator_bb.bollinger_lband()
df[f"{colprefix}volatility_bbw"] = indicator_bb.bollinger_wband()
df[f"{colprefix}volatility_bbp"] = indicator_bb.bollinger_pband()
df[f"{colprefix}volatility_bbhi"] = indicator_bb.bollinger_hband_indicator(
)
df[f"{colprefix}volatility_bbli"] = indicator_bb.bollinger_lband_indicator(
)
# Keltner Channel
indicator_kc = KeltnerChannel(close=df[close],
high=df[high],
low=df[low],
window=10,
fillna=fillna)
df[f"{colprefix}volatility_kcc"] = indicator_kc.keltner_channel_mband()
df[f"{colprefix}volatility_kch"] = indicator_kc.keltner_channel_hband()
df[f"{colprefix}volatility_kcl"] = indicator_kc.keltner_channel_lband()
df[f"{colprefix}volatility_kcw"] = indicator_kc.keltner_channel_wband()
df[f"{colprefix}volatility_kcp"] = indicator_kc.keltner_channel_pband()
df[f"{colprefix}volatility_kchi"] = indicator_kc.keltner_channel_hband_indicator(
)
df[f"{colprefix}volatility_kcli"] = indicator_kc.keltner_channel_lband_indicator(
)
# Donchian Channel
indicator_dc = DonchianChannel(high=df[high],
low=df[low],
close=df[close],
window=20,
offset=0,
fillna=fillna)
df[f"{colprefix}volatility_dcl"] = indicator_dc.donchian_channel_lband()
df[f"{colprefix}volatility_dch"] = indicator_dc.donchian_channel_hband()
df[f"{colprefix}volatility_dcm"] = indicator_dc.donchian_channel_mband()
df[f"{colprefix}volatility_dcw"] = indicator_dc.donchian_channel_wband()
df[f"{colprefix}volatility_dcp"] = indicator_dc.donchian_channel_pband()
if not vectorized:
# Average True Range
df[f"{colprefix}volatility_atr"] = AverageTrueRange(
close=df[close],
high=df[high],
low=df[low],
window=10,
fillna=fillna).average_true_range()
# Ulcer Index
df[f"{colprefix}volatility_ui"] = UlcerIndex(
close=df[close], window=14, fillna=fillna).ulcer_index()
return df
window=20,
window_dev=2)
# Add Bollinger Bands features
# df_bars['bb_bbm'] = indicator_bb.bollinger_mavg()
# df_bars['bb_bbh'] = indicator_bb.bollinger_hband()
#df_bars['bb_bbl'] = indicator_bb.bollinger_lband()
# Add Bollinger Band high indicator
# df_bars['bb_bbhi'] = indicator_bb.bollinger_hband_indicator()
# Add Bollinger Band low indicator
# df_bars['bb_bbli'] = indicator_bb.bollinger_lband_indicator()
# Add Width Size Bollinger Bands
df_bars['bb_bbw_' + tf] = indicator_bb.bollinger_wband()
# Add Percentage Bollinger Bands
df_bars['bb_bbp_' + tf] = indicator_bb.bollinger_pband()
# df_bars.insert(loc=0, column='pair', value=pair)
# df_bars.insert(loc=1, column='tf', value=tf)
# df_bars['pair'] = pair
# df_bars['High'] = df_bars.High.astype(np.float64)
# df_bars['Low'] = df_bars.Low.astype(np.float64)
# df_bars['Close'] = df_bars.Close.astype(np.float64)
df_bars['rsi_' +
tf] = RSIIndicator(close=df_bars["Close"]).rsi()
# df_bars = add_all_ta_features(
def handle(self, *args, **options):
# import pdb
# pdb.set_trace()
if not options['update']:
NSETechnical.objects.all().delete()
symbols = Symbol.objects.all()
for symbol in symbols:
nse_history_data = NSEHistoricalData.objects.filter(
symbol__symbol_name=symbol).order_by('timestamp')
if not nse_history_data:
continue
nse_technical = pd.DataFrame(
list(
nse_history_data.values('timestamp', 'open', 'high', 'low',
'close', 'total_traded_quantity')))
'''
Moving average convergence divergence
'''
indicator_macd = MACD(close=nse_technical['close'],
window_slow=26,
window_fast=12,
window_sign=9,
fillna=False)
nse_technical["trend_macd"] = indicator_macd.macd()
nse_technical["trend_macd_signal"] = indicator_macd.macd_signal()
nse_technical["trend_macd_diff"] = indicator_macd.macd_diff()
'''
Simple Moving Average
'''
nse_technical["trend_sma_fast"] = SMAIndicator(
close=nse_technical['close'], window=12,
fillna=False).sma_indicator()
nse_technical["trend_sma_slow"] = SMAIndicator(
close=nse_technical['close'], window=26,
fillna=False).sma_indicator()
'''
Exponential Moving Average
'''
nse_technical["trend_ema_fast"] = EMAIndicator(
close=nse_technical['close'], window=12,
fillna=False).ema_indicator()
nse_technical["trend_ema_slow"] = EMAIndicator(
close=nse_technical['close'], window=26,
fillna=False).ema_indicator()
'''
Ichimoku Indicator
'''
indicator_ichi = IchimokuIndicator(
high=nse_technical['high'],
low=nse_technical['low'],
window1=9,
window2=26,
window3=52,
visual=False,
fillna=False,
)
nse_technical[
"trend_ichimoku_conv"] = indicator_ichi.ichimoku_conversion_line(
)
nse_technical[
"trend_ichimoku_base"] = indicator_ichi.ichimoku_base_line()
nse_technical["trend_ichimoku_a"] = indicator_ichi.ichimoku_a()
nse_technical["trend_ichimoku_b"] = indicator_ichi.ichimoku_b()
indicator_ichi_visual = IchimokuIndicator(
high=nse_technical['high'],
low=nse_technical['low'],
window1=9,
window2=26,
window3=52,
visual=True,
fillna=False,
)
nse_technical[
"trend_visual_ichimoku_a"] = indicator_ichi_visual.ichimoku_a(
)
nse_technical[
"trend_visual_ichimoku_b"] = indicator_ichi_visual.ichimoku_b(
)
'''
Bollinger Band
'''
indicator_bb = BollingerBands(close=nse_technical['close'],
window=20,
window_dev=2,
fillna=False)
nse_technical["volatility_bbm"] = indicator_bb.bollinger_mavg()
nse_technical["volatility_bbh"] = indicator_bb.bollinger_hband()
nse_technical["volatility_bbl"] = indicator_bb.bollinger_lband()
nse_technical["volatility_bbw"] = indicator_bb.bollinger_wband()
nse_technical["volatility_bbp"] = indicator_bb.bollinger_pband()
nse_technical[
"volatility_bbhi"] = indicator_bb.bollinger_hband_indicator()
nse_technical[
"volatility_bbli"] = indicator_bb.bollinger_lband_indicator()
'''
Accumulation Distribution Index
'''
nse_technical["volume_adi"] = AccDistIndexIndicator(
high=nse_technical['high'],
low=nse_technical['low'],
close=nse_technical['close'],
volume=nse_technical['total_traded_quantity'],
fillna=False).acc_dist_index()
'''
Money Flow Index
'''
nse_technical["volume_mfi"] = MFIIndicator(
high=nse_technical['high'],
low=nse_technical['low'],
close=nse_technical['close'],
volume=nse_technical['total_traded_quantity'],
window=14,
fillna=False,
).money_flow_index()
'''
Relative Strength Index (RSI)
'''
nse_technical["momentum_rsi"] = RSIIndicator(
close=nse_technical['close'], window=14, fillna=False).rsi()
'''
Stoch RSI (StochRSI)
'''
indicator_srsi = StochRSIIndicator(close=nse_technical['close'],
window=14,
smooth1=3,
smooth2=3,
fillna=False)
nse_technical["momentum_stoch_rsi"] = indicator_srsi.stochrsi()
nse_technical["momentum_stoch_rsi_k"] = indicator_srsi.stochrsi_k()
nse_technical["momentum_stoch_rsi_d"] = indicator_srsi.stochrsi_d()
nse_technical.replace({np.nan: None}, inplace=True)
nse_technical.replace([np.inf, -np.inf], None, inplace=True)
list_to_create = []
list_to_update = []
for index in range(len(nse_history_data) - 1, -1, -1):
data = nse_history_data[index]
if data.technicals:
break
technical = NSETechnical(
nse_historical_data=data,
trend_macd=nse_technical['trend_macd'][index],
trend_macd_signal=nse_technical['trend_macd_signal']
[index],
trend_macd_diff=nse_technical['trend_macd_diff'][index],
trend_sma_fast=nse_technical['trend_sma_fast'][index],
trend_sma_slow=nse_technical['trend_sma_slow'][index],
trend_ema_fast=nse_technical['trend_ema_fast'][index],
trend_ema_slow=nse_technical['trend_ema_slow'][index],
trend_ichimoku_conv=nse_technical['trend_ichimoku_conv']
[index],
trend_ichimoku_base=nse_technical['trend_ichimoku_base']
[index],
trend_ichimoku_a=nse_technical['trend_ichimoku_a'][index],
trend_ichimoku_b=nse_technical['trend_ichimoku_b'][index],
trend_visual_ichimoku_a=nse_technical[
'trend_visual_ichimoku_a'][index],
trend_visual_ichimoku_b=nse_technical[
'trend_visual_ichimoku_b'][index],
volatility_bbm=nse_technical['volatility_bbm'][index],
volatility_bbh=nse_technical['volatility_bbh'][index],
volatility_bbl=nse_technical['volatility_bbl'][index],
volatility_bbw=nse_technical['volatility_bbw'][index],
volatility_bbp=nse_technical['volatility_bbp'][index],
volatility_bbhi=nse_technical['volatility_bbhi'][index],
volatility_bbli=nse_technical['volatility_bbli'][index],
volume_adi=nse_technical['volume_adi'][index],
volume_mfi=nse_technical['volume_mfi'][index],
momentum_rsi=nse_technical['momentum_rsi'][index],
momentum_stoch_rsi=nse_technical['momentum_stoch_rsi']
[index],
momentum_stoch_rsi_k=nse_technical['momentum_stoch_rsi_k']
[index],
momentum_stoch_rsi_d=nse_technical['momentum_stoch_rsi_d']
[index])
data.technicals = True
list_to_update.append(data)
list_to_create.append(technical)
NSETechnical.objects.bulk_create(list_to_create)
NSEHistoricalData.objects.bulk_update(list_to_update,
['technicals'])
print(f"Technicals updated for {symbol}")
def GetPriceDataFromExchangeFinnHub(event, context):
retVal = {}
retVal["data"] = []
# For debugging the input, write the EVENT to CloudWatch logs
print(json.dumps(event))
# Data is sent to Lambda via a HTTPS POST call. We want to get to the payload send by Snowflake
event_body = event["body"]
payload = json.loads(event_body)
for row in payload["data"]:
sflkRowRef = row[
0] # This is how Snowflake keeps track of data as it gets returned
symbol = row[
1] # The data passed in from Snowflake that the input row contains.
fromDate = row[2]
toDate = row[3]
# Will return URL without token to Snowflake for tracking
URL = f'https://finnhub.io/api/v1/stock/candle?symbol={symbol}&resolution=D&from={fromDate}&to={toDate}'
# Add our FinnHubAPI Key to the end of the URL.
# This is in a new variable which will not be returned to Snowflake
URLWithToken = f'{URL}&token={FinnHubAPI.TOKEN}'
# GET data from the API
httpData = requests.get(url=URLWithToken).json()
# Convert to Pandas DataFrame
df = pd.DataFrame(httpData)
# Add the column names
print("Adding column names")
df.columns = [
"Close", "High", "Low", "Open", "Status", "OpenTime", "Volume"
]
# Set DateTime columns to correct type
df['OpenTime'] = pd.to_datetime(df['OpenTime'], unit='ms')
df['Open'] = df['Open'].astype(float)
df['High'] = df['High'].astype(float)
df['Low'] = df['Low'].astype(float)
df['Close'] = df['Close'].astype(float)
df['Volume'] = df['Volume'].astype(float)
# Clean NaN values
print("Cleaning NA values")
df = dropna(df)
# Calculate the Bollinger Bands indicator
indicator_bb = BollingerBands(close=df["Close"], n=20, ndev=2)
df['bb_bbm'] = indicator_bb.bollinger_mavg()
df['bb_bbh'] = indicator_bb.bollinger_hband()
df['bb_bbl'] = indicator_bb.bollinger_lband()
df['bb_bbhi'] = indicator_bb.bollinger_hband_indicator()
df['bb_bbli'] = indicator_bb.bollinger_lband_indicator()
df['bb_bbw'] = indicator_bb.bollinger_wband()
df['bb_bbp'] = indicator_bb.bollinger_pband()
print("converting OHLC pandas to JSON. This does it as a string")
buffer = df.to_json(orient="records")
print("Interpret the JSON string into a dictionary for output")
jsonResponse = json.loads(buffer)
# Prepare the output response
response = {}
response["url"] = URL
response["response"] = jsonResponse
retVal["data"].append([sflkRowRef, response])
# For debugging the output, write the RETurn VALue to CloudWatch logs
# print(json.dumps(retVal))
return retVal