def sma(s_interval: str, df_stock: pd.DataFrame, length: int,
offset: int) -> pd.DataFrame:
"""Gets simple moving average (EMA) for stock
Parameters
----------
s_interval: str
Data interval
df_stock: pd.DataFrame
Dataframe of dates and prices
length: int
Length of SMA window
offset: int
Length of offset
Returns
----------
df_ta: pd.DataFrame
Dataframe containing prices and SMA
"""
# Daily
if s_interval == "1440min":
df_ta = ta.sma(df_stock["Adj Close"], length=length,
offset=offset).dropna()
# Intraday
else:
df_ta = ta.sma(df_stock["Close"], length=length,
offset=offset).dropna()
return pd.DataFrame(df_ta)
def task():
for i in range(100):
print('check')
cursor.execute("SELECT * from config")
results = cursor.fetchone()
url = results[8]
resjson = requests.get(url).json()
if (resjson['s'] != 'error'):
candleinfo = resjson['candles']
columns = ['timestamp', 'Open', 'High', 'Low', 'Close', 'OI']
df = pd.DataFrame(candleinfo, columns=columns)
Open = df['Open']
High = df['High']
Low = df['Low']
Close = df['Close'].values
sma9 = ta.sma(df["Close"], length=9)
sma21 = ta.sma(df["Close"], length=21)
value = (Open + High + Low + Close) / 4
# print(sma9.iloc[-2])
# print(sma21.iloc[-2])
if (sma9.iloc[-2] < sma21.iloc[-2]) and (sma9.iloc[-9] >
sma21.iloc[-9]):
print('BUy')
storetrade(75, 1, 'nifty', Close.tail(1), 1, 'sma921')
if (sma9.iloc[-2] > sma21.iloc[-2]) and (sma9.iloc[-9] <
sma21.iloc[-9]):
print('Sell')
storetrade(75, -1, 'nifty', Close[-1], 1, 'sma921')
time.sleep(60)
def act(self):
vals = self._getvals()
self.lowersma = ta.sma(vals, length=GoldenCross.LOWER_LENGTH)
self.uppersma = ta.sma(vals, length=GoldenCross.UPPER_LENGTH)
if not self._lower_above_upper():
self._handle_negative()
return
if self.negative_flag:
self._reset_negative_flag()
self._handle_positive()
def add_sma_crossover():
data['LMA'] = ta.sma(data['4. close'], 21)
data['SMA'] = ta.sma(data['4. close'], 9)
data['psma'] = data['SMA'].shift(1)
data['plma'] = data['LMA'].shift(1)
#if (((data['SMA'][-1]>data['LMA'][-1])and(data['psma'][-1]<data['plma'][-1])) or ((data['SMA'][-1]<data['LMA'][-1])and(data['psma'][-1]>data['plma'][-1]))) or (((data['SMA'][-2]>data['LMA'][-2])and(data['psma'][-2]<data['plma'][-2])) or ((data['SMA'][-2]<data['LMA'][-2])and(data['psma'][-2]>data['plma'][-2]))) :
data['buy_sma'] = (data['SMA'] > data['LMA']) & (data['psma'] <
data['plma'])
data['sell_sma'] = (data['SMA'] < data['LMA']) & (data['psma'] >
data['plma'])
def todf(symbols=None, range=200):
if symbols is None:
raise ValueError("Require at least 1 Symbol")
tick = hist_price(symbols, start=dateRange(range)[0])
df = pd.DataFrame(columns=[
"symbol", "dip50", "dip100", "pinBar50", "pinBar150", "tweezers50",
"tweezers150", "oneSolCrow50", "oneSolCrow150", "morEveStar50",
"morEveStar150", "engulfing50", "engulfing150", "Trend"
])
for i in symbols:
hist = tick.xs(i, level=0)
sma50 = ta.sma(hist['close'], length=50)
sma100 = ta.sma(hist['close'], length=100)
sma150 = ta.sma(hist['close'], length=150)
ema20 = ta.ema(hist['close'], length=20)
ema40 = ta.ema(hist['close'], length=40)
trnd = trend(sma50, sma150)
prev2 = candle_dict(hist['open'][len(hist) - 2 - 1],
hist['high'][len(hist) - 2 - 1],
hist['low'][len(hist) - 2 - 1],
hist['close'][len(hist) - 2 - 1])
prev1 = candle_dict(hist['open'][len(hist) - 1 - 1],
hist['high'][len(hist) - 1 - 1],
hist['low'][len(hist) - 1 - 1],
hist['close'][len(hist) - 1 - 1])
current = candle_dict(hist['open'][len(hist) - 1],
hist['high'][len(hist) - 1],
hist['low'][len(hist) - 1],
hist['close'][len(hist) - 1])
datadict = {
"symbol": i,
"dip50": dip50(hist, sma50, sma150, ema20, ema40),
"dip100": dip100(hist, sma50, sma150, sma100, ema20, ema40),
"pinBar50": PinBar(current, sma50[-1], trnd),
"pinBar150": PinBar(current, sma150[-1], trnd),
"tweezers50": tweezers(current, prev1, sma50[-1], trnd),
"tweezers150": tweezers(current, prev1, sma150[-1], trnd),
"oneSolCrow50": oneSolCrow(current, prev1, sma50[-1], trnd),
"oneSolCrow150": oneSolCrow(current, prev1, sma150[-1], trnd),
"morEveStar50": morEveStar(current, prev1, prev2, sma50[-1], trnd),
"morEveStar150": morEveStar(current, prev1, prev2, sma150[-1],
trnd),
"engulfing50": engulfing(current, prev1, sma50[-1], trnd),
"engulfing150": engulfing(current, prev1, sma150[-1], trnd),
"Trend": trnd
}
df = df.append(datadict, ignore_index=True)
df = df.set_index('symbol')
return df
def on_15min_bar(self, bar: BarData):
""""""
self.am15.update_bar(bar)
if not self.am15.inited:
return
close_15 = pd.Series(self.am15.close_array)
self.fast_ma = ta.sma(close_15, self.fast_window).iloc[-1]
self.slow_ma = ta.sma(close_15, self.slow_window).iloc[-1]
if self.fast_ma > self.slow_ma:
self.ma_trend = 1
else:
self.ma_trend = -1
def on_5min_bar(self, bar: BarData):
""""""
self.am.update_bar(bar)
if not self.am.inited:
self.set_signal_pos(0)
close = pd.Series(self.am.close_array)
fast_ma = ta.sma(close, self.fast_window).iloc[-1]
slow_ma = ta.sma(close, self.slow_window).iloc[-1]
if fast_ma > slow_ma:
self.set_signal_pos(1)
elif fast_ma < slow_ma:
self.set_signal_pos(-1)
else:
self.set_signal_pos(0)
def consume(self, candle: TDACandle):
self.candles.append(candle)
vals = self._getvals()[0]
averages = list(
filter(lambda a: a is not None,
[ta.sma(vals, length=length) for length in self.lengths]))
return averages
def on_5min_bar(self, bar: BarData):
""""""
for orderid in self.vt_orderids:
self.cancel_order(orderid)
self.vt_orderids.clear()
am = self.am
am.update_bar(bar)
if not am.inited:
return
high = pd.Series(am.high_array)
low = pd.Series(am.low_array)
close = pd.Series(am.close_array)
range_ = ta.true_range(high, low, close)
basis = ta.sma(close, self.kk_length)
band = ta.sma(range_, self.kk_length)
up = basis + self.kk_dev * band
down = basis - self.kk_dev * band
self.kk_up, self.kk_down = up.iloc[-1], down.iloc[-1]
if self.pos == 0:
self.intra_trade_high = bar.high_price
self.intra_trade_low = bar.low_price
self.send_oco_order(self.kk_up, self.kk_down, self.fixed_size)
elif self.pos > 0:
self.intra_trade_high = max(self.intra_trade_high, bar.high_price)
self.intra_trade_low = bar.low_price
vt_orderids = self.sell(self.intra_trade_high * (1 - self.trailing_percent / 100),
abs(self.pos), True)
self.vt_orderids.extend(vt_orderids)
elif self.pos < 0:
self.intra_trade_high = bar.high_price
self.intra_trade_low = min(self.intra_trade_low, bar.low_price)
vt_orderids = self.cover(self.intra_trade_low * (1 + self.trailing_percent / 100),
abs(self.pos), True)
self.vt_orderids.extend(vt_orderids)
self.put_event()
def extract_features(self):
min_max_scaler = preprocessing.MinMaxScaler()
# RSI
# ref in https://arxiv.org/pdf/1911.10107.pdf
rsi = ta.rsi(self.data.close, length=28)
normalized_rsi = rsi.to_numpy().reshape(-1,
1) / 100 - 0.5 # (-0.5, 0.5)
# normalized close
# ref in https://arxiv.org/pdf/1911.10107.pdf
min_max_scaler = preprocessing.MinMaxScaler()
normalized_close = min_max_scaler.fit_transform(
self.data.close.to_frame()).reshape(-1, 1) - 0.5
# normalized return
# ref in https://arxiv.org/pdf/1911.10107.pdf
ret_window = 60
ret_60 = self.data.close / self.data.close.shift(ret_window) - 1
normalized_ret_60 = ret_60 / ta.stdev(
ret_60, ret_window) #ret_60.rolling(ret_window).std()
normalized_ret_60 = normalized_ret_60.to_numpy().reshape(-1, 1)
ret_window = 120
ret_120 = self.data.close / self.data.close.shift(ret_window) - 1
normalized_ret_120 = ret_120 / ta.stdev(ret_120, ret_window)
normalized_ret_120 = normalized_ret_120.to_numpy().reshape(-1, 1)
# MACD indicators
# ref in https://arxiv.org/pdf/1911.10107.pdf
qt = (ta.sma(self.data.close, 30) -
ta.sma(self.data.close, 60)) / ta.stdev(self.data.close, 60)
macd = qt / ta.stdev(qt, 60)
macd = macd.to_numpy().reshape(-1, 1)
# concat features
features = np.concatenate(
(normalized_rsi, normalized_close, normalized_ret_60,
normalized_ret_120, macd),
axis=1)
self.features = features
def __setHistory__(self, path):
df = pd.read_csv(path)
df = df.dropna()
df = df.iloc[::-1]
df = df.reset_index(drop=True)
sma50 = ta.sma(df["close"], length=50)
df = pd.concat([
df,
sma50,
], axis=1)
df = df[(df['SMA_50'] > 0)]
df = df.reset_index(drop=True)
return df
def pandasta():
cursor.execute("SELECT * from config")
results = cursor.fetchone()
url = results[8]
# url = 'https://data.fyers.in/history/V7/?symbol=NSE%3ANIFTY50-INDEX&resolution=1&from=1620561415&to=1620790435&token_id=gAAAAABgm0w-XnrWX52NA-h4wMaK6YIxWE25nhMIqpOHjmBVyaiMjh0qIAABt0Z7x_iT0_h8SBgpUTb_qFQX9flwWap_ZvWhrqwpIQ0ma-obBr7UqGOeVqM%3D&contFlag=1&marketStat=75946787eb1b0c34d9effd84d9a48ff3&dataReq=1620790375'
resjson = requests.get(url).json()
candleinfo = resjson['candles']
columns = ['timestamp', 'Open', 'High', 'Low', 'Close', 'OI']
df = pd.DataFrame(candleinfo, columns=columns)
df.reset_index()
Open = df['Open']
High = df['High']
Low = df['Low']
Close = df['Close'].values
sma9 = ta.sma(df["Close"], length=9)
sma21 = ta.sma(df["Close"], length=21)
print(Close[-1])
# print(macdhist[-2])
# macdhist = macdhist[~np.isnan(macdhist)]
# return render_template('index.html', results=candleinfo)
return 'macd'
def on_bar(self, bar: BarData):
"""
Callback of new bar data update.
"""
am = self.am
am.update_bar(bar)
if not am.inited:
return
close = pd.Series(am.close_array)
fast_ma = ta.sma(close, self.fast_window)
self.fast_ma0 = fast_ma.iloc[-1]
self.fast_ma1 = fast_ma.iloc[-2]
slow_ma = ta.sma(close, self.slow_window)
self.slow_ma0 = slow_ma.iloc[-1]
self.slow_ma1 = slow_ma.iloc[-2]
cross_over = self.fast_ma0 > self.slow_ma0 and self.fast_ma1 < self.slow_ma1
cross_below = self.fast_ma0 < self.slow_ma0 and self.fast_ma1 > self.slow_ma1
if cross_over:
if self.pos == 0:
self.buy(bar.close_price, 1)
elif self.pos < 0:
self.cover(bar.close_price, 1)
self.buy(bar.close_price, 1)
elif cross_below:
if self.pos == 0:
self.short(bar.close_price, 1)
elif self.pos > 0:
self.sell(bar.close_price, 1)
self.short(bar.close_price, 1)
self.put_event()
def calculate_moving_average(source, debug_param=False):
'''
### Generate mean values
# Generate features - Mean value
'''
if not debug_param:
#meanList = [2, 5, 8, 10, 13, 15, 18, 20, 22, 34, 40, 50, 75, 100, 125, 150, 175, 200];
meanList = [20, 50, 75, 100, 150, 200]
# meanList = [5, 10, 20, 50, 100, 200];
else:
meanList = [50, 200]
close = source['Close']
meanfeatures = pd.DataFrame(index=source.index)
for i in meanList:
# Mean
ta.sma(close, i, 0)
meanCol = ta.sma(close, i, 0) #MA(close, i, 0); # Trailing MA with i
# meanCol.fillna(0, inplace=True)
meanColreshaped = np.reshape(meanCol.values,
(1, np.product(meanCol.values.shape)))[0]
# Calculate diff from price in %
diffPriceCol = np.divide(meanColreshaped - close.values, close.values)
temp_source = pd.DataFrame(diffPriceCol,
columns=['MA' + str(i) + 'Norm'])
# print(temp_source)
meanfeatures = meanfeatures.join(temp_source)
# meanTable(:,i) = diffPriceCol;
# print("Calculated MA{}".format(i));
print("Number of features: {}".format(meanfeatures.shape))
print(meanfeatures.head(5))
return meanfeatures
def generate_features_data():
market_data_df = pd.DataFrame(
columns=['timestamp', 'high', 'low', 'open', 'close', 'volume'])
market_data_df = market_data_df.append(data())
timestamp_df = market_data_df['timestamp'].copy(deep=True)
slow_vwma_value_df = pd.DataFrame(
vwma(market_data_df.close, market_data_df.volume, length=15, offset=0))
fast_vwma_value_df = pd.DataFrame(
vwma(market_data_df.close, market_data_df.volume, length=5, offset=0))
slow_sma_value_df = pd.DataFrame(sma(market_data_df.close, 15))
fast_sma_value_df = pd.DataFrame(sma(market_data_df.close, 5))
rsi_data_value_df = pd.DataFrame(rsi(market_data_df.close, 10))
slow_vwma_df = pd.concat([timestamp_df, slow_vwma_value_df], axis=1)
fast_vwma_df = pd.concat([timestamp_df, fast_vwma_value_df], axis=1)
slow_sma_df = pd.concat([timestamp_df, slow_sma_value_df], axis=1)
fast_sma_df = pd.concat([timestamp_df, fast_sma_value_df], axis=1)
rsi_df = pd.concat([timestamp_df, rsi_data_value_df], axis=1)
slow_vwma_df.to_csv('slow_vwma_data.csv', index=False)
fast_vwma_df.to_csv('fast_vwma_data.csv', index=False)
slow_sma_df.to_csv('slow_sma_data.csv', index=False)
fast_sma_df.to_csv('fast_sma_data.csv', index=False)
rsi_df.to_csv('rsi_data.csv', index=False)
def on_15min_bar(self, bar: BarData):
""""""
self.cancel_all()
am = self.am
am.update_bar(bar)
if not am.inited:
return
close = pd.Series(am.close_array)
high = pd.Series(am.high_array)
low = pd.Series(am.low_array)
standard_deviation = ta.stdev(close=close, length=self.boll_window)
deviations = self.boll_dev * standard_deviation
mid = ta.sma(close=close, length=self.boll_window)
self.boll_up, self.boll_down = (mid + deviations).iloc[-1], (mid - deviations).iloc[-1]
self.cci_value = ta.cci(high, low, close, self.cci_window).iloc[-1]
self.atr_value = ta.atr(high, low, close, self.atr_window).iloc[-1]
if self.pos == 0:
self.intra_trade_high = bar.high_price
self.intra_trade_low = bar.low_price
if self.cci_value > 0:
self.buy(self.boll_up, self.fixed_size, True)
elif self.cci_value < 0:
self.short(self.boll_down, self.fixed_size, True)
elif self.pos > 0:
self.intra_trade_high = max(self.intra_trade_high, bar.high_price)
self.intra_trade_low = bar.low_price
self.long_stop = self.intra_trade_high - self.atr_value * self.sl_multiplier
self.sell(self.long_stop, abs(self.pos), True)
elif self.pos < 0:
self.intra_trade_high = bar.high_price
self.intra_trade_low = min(self.intra_trade_low, bar.low_price)
self.short_stop = self.intra_trade_low + self.atr_value * self.sl_multiplier
self.cover(self.short_stop, abs(self.pos), True)
self.put_event()
def sma(values: pd.DataFrame, length: int, offset: int) -> pd.DataFrame:
"""Gets simple moving average (EMA) for stock
Parameters
----------
values: pd.DataFrame
Dataframe of dates and prices
length: int
Length of SMA window
offset: int
Length of offset
Returns
----------
pd.DataFrame
Dataframe containing prices and SMA
"""
return pd.DataFrame(ta.sma(values, length=length, offset=offset)).dropna()
def on_15min_bar(self, bar: BarData):
self.cancel_all()
am = self.am
am.update_bar(bar)
if not am.inited:
return
high = pd.Series(am.close_array)
low = pd.Series(am.low_array)
close = pd.Series(am.close_array)
atr_array = ta.atr(high, low, close, self.atr_length)
self.atr_value = atr_array.iloc[-1]
self.atr_ma = ta.sma(atr_array, self.atr_ma_length).iloc[-1]
self.rsi_value = ta.rsi(close, self.rsi_length).iloc[-1]
if self.pos == 0:
self.intra_trade_high = bar.high_price
self.intra_trade_low = bar.low_price
self.trading_size = self.trading_money / bar.close_price
if self.atr_value > self.atr_ma:
if self.rsi_value > self.rsi_buy:
self.buy(bar.close_price + 5, self.trading_size)
elif self.rsi_value < self.rsi_sell:
self.short(bar.close_price - 5, self.trading_size)
elif self.pos > 0:
self.intra_trade_high = max(self.intra_trade_high, bar.high_price)
self.intra_trade_low = bar.low_price
long_stop = self.intra_trade_high * \
(1 - self.trailing_percent / 100)
self.sell(long_stop, abs(self.pos), stop=True)
elif self.pos < 0:
self.intra_trade_low = min(self.intra_trade_low, bar.low_price)
self.intra_trade_high = bar.high_price
short_stop = self.intra_trade_low * \
(1 + self.trailing_percent / 100)
self.cover(short_stop, abs(self.pos), stop=True)
int(data['event_time'] / 1000),
data['kline']['open_price'], data['kline']['high_price'],
data['kline']['low_price'], data['kline']['close_price'],
data['kline']['base_volume']
])
if len(data_list) < min_items:
print(
f"Please wait, we need {min_items - len(data_list)} more klines!"
)
else:
# We create a completely new dataframe with each loop. There is also the possibility to work with
# `pd.concat()` or `df.append()`:
# https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.append.html
df = pd.DataFrame(data_list,
columns=[
'time', 'open', 'high', 'low',
'close', 'volume'
])
# Now we extend the array with new columns, add the date and the values of the RSI and SMA
df["date"] = pd.to_datetime(df["time"], unit="s")
df["rsi"] = ta.rsi(close=df.close, length=10)
df["sma10"] = ta.sma(df.close, length=10)
print(
f"Extended dataframe with RSI ({df['rsi'].iloc[-1]}) and SMA10 ({df['sma10'].iloc[-1]}) for "
f"symbol '{data['symbol']}':\r\n{df}\r\n")
except TypeError as error_msg:
print("TypeError: " + str(error_msg))
except KeyError as error_msg:
if "kline" not in str(error_msg):
print("KeyError: " + str(error_msg))
api_keys = {}
with open(secrets_filename, 'r') as f:
api_keys = json.loads(f.read())
bot = TelegramBot(api_keys['token'], int(api_keys['user_id']))
dataframes = {}
for filename in os.listdir('datasets'):
symbol = filename.split(".")[0]
df = pandas.read_csv('datasets/{}'.format(filename))
if df.empty:
continue
df['20sma'] = ta.sma(df['Close'], length=20)
df['stddev'] = df['Close'].rolling(window=20).std()
df['lower_band'] = df['20sma'] - (1 * df['stddev'])
df['upper_band'] = df['20sma'] + (1 * df['stddev'])
df['TR'] = abs(df['High'] - df['Low'])
df['ATR'] = df['TR'].rolling(window=20).mean()
df['lower_keltner'] = df['20sma'] - (df['ATR'] * 1)
df['upper_keltner'] = df['20sma'] + (df['ATR'] * 1)
df['diff'] = (df['upper_band'] - df['lower_band']) / df['20sma']
ADX = ta.adx(df['High'], df['Low'], df['Close'], length=14)
RSI = ta.rsi(df['Close'], length=14)
def tight_squeeze(df):
def get_SMA(data_series_of_target_feature, lookback_value):
return panda.sma(data_series_of_target_feature, length=lookback_value)
def sma(l_args, s_ticker, s_interval, df_stock):
parser = argparse.ArgumentParser(
prog='sma',
description=
""" Moving Averages are used to smooth the data in an array to
help eliminate noise and identify trends. The Simple Moving Average is literally
the simplest form of a moving average. Each output value is the average of the
previous n values. In a Simple Moving Average, each value in the time period carries
equal weight, and values outside of the time period are not included in the average.
This makes it less responsive to recent changes in the data, which can be useful for
filtering out those changes. """)
parser.add_argument('-l',
"--length",
dest="l_length",
type=lambda s: [int(item) for item in s.split(',')],
default=[20, 50],
help='length of MA window')
parser.add_argument('-o',
"--offset",
action="store",
dest="n_offset",
type=check_positive,
default=0,
help='offset')
try:
(ns_parser, l_unknown_args) = parser.parse_known_args(l_args)
if l_unknown_args:
print(
f"The following args couldn't be interpreted: {l_unknown_args}\n"
)
return
# Daily
if s_interval == "1440min":
plt.plot(df_stock.index,
df_stock['5. adjusted close'].values,
color='k')
l_legend = list()
l_legend.append(s_ticker)
for length in ns_parser.l_length:
df_ta = ta.sma(df_stock['5. adjusted close'],
length=length,
offset=ns_parser.n_offset).dropna()
plt.plot(df_ta.index, df_ta.values)
l_legend.append(f"{length} SMA")
plt.title(f"SMA on {s_ticker}")
plt.xlim(df_stock.index[0], df_stock.index[-1])
plt.xlabel('Time')
plt.ylabel('Share Price ($)')
plt.legend(l_legend)
plt.grid(b=True, which='major', color='#666666', linestyle='-')
plt.minorticks_on()
plt.grid(b=True,
which='minor',
color='#999999',
linestyle='-',
alpha=0.2)
plt.show()
# Intraday
else:
plt.plot(df_stock.index, df_stock['4. close'].values, color='k')
l_legend = list()
l_legend.append(s_ticker)
for length in ns_parser.n_length:
df_ta = ta.sma(df_stock['4. close'],
length=length,
offset=ns_parser.n_offset).dropna()
plt.plot(df_ta.index, df_ta.values)
l_legend.append(f"{length} SMA")
plt.title(f"SMA on {s_ticker}")
plt.xlim(df_stock.index[0], df_stock.index[-1])
plt.xlabel('Time')
plt.ylabel('Share Price ($)')
plt.legend(l_legend)
plt.grid(b=True, which='major', color='#666666', linestyle='-')
plt.minorticks_on()
plt.grid(b=True,
which='minor',
color='#999999',
linestyle='-',
alpha=0.2)
plt.show()
print("")
except:
print("")
def add_plots(df: pd.DataFrame, additional_charts: Dict[str, bool]):
"""Add additional plots to the candle chart.
Parameters
----------
df : pd.DataFrame
The source data
additional_charts : Dict[str, bool]
A dictionary of flags to include additional charts
Returns
-------
Tuple
Tuple of lists containing the plots, legends and subplot legends
"""
panel_number = 2
plots_to_add = []
legends = []
subplot_legends = []
if additional_charts["ad"]:
ad = ta.ad(df["High"], df["Low"], df["Close"], df["Volume"])
ad_plot = mpf.make_addplot(ad, panel=panel_number)
plots_to_add.append(ad_plot)
subplot_legends.extend([panel_number * 2, ["AD"]])
panel_number += 1
if additional_charts["bbands"]:
bbands = ta.bbands(df["Close"])
bbands = bbands.drop("BBB_5_2.0", axis=1)
bbands_plot = mpf.make_addplot(bbands, panel=0)
plots_to_add.append(bbands_plot)
legends.extend(["Lower BBand", "Middle BBand", "Upper BBand"])
if additional_charts["cci"]:
cci = ta.cci(df["High"], df["Low"], df["Close"])
cci_plot = mpf.make_addplot(cci, panel=panel_number)
plots_to_add.append(cci_plot)
subplot_legends.extend([panel_number * 2, ["CCI"]])
panel_number += 1
if additional_charts["ema"]:
ema = ta.ema(df["Close"])
ema_plot = mpf.make_addplot(ema, panel=0)
plots_to_add.append(ema_plot)
legends.append("10 EMA")
if additional_charts["rsi"]:
rsi = ta.rsi(df["Close"])
rsi_plot = mpf.make_addplot(rsi, panel=panel_number)
plots_to_add.append(rsi_plot)
subplot_legends.extend([panel_number * 2, ["RSI"]])
panel_number += 1
if additional_charts["obv"]:
obv = ta.obv(df["Close"], df["Volume"])
obv_plot = mpf.make_addplot(obv, panel=panel_number)
plots_to_add.append(obv_plot)
subplot_legends.extend([panel_number * 2, ["OBV"]])
panel_number += 1
if additional_charts["sma"]:
sma_length = [20, 50]
for length in sma_length:
sma = ta.sma(df["Close"], length=length)
sma_plot = mpf.make_addplot(sma, panel=0)
plots_to_add.append(sma_plot)
legends.append(f"{length} SMA")
if additional_charts["vwap"]:
vwap = ta.vwap(df["High"], df["Low"], df["Close"], df["Volume"])
vwap_plot = mpf.make_addplot(vwap, panel=0)
plots_to_add.append(vwap_plot)
legends.append("vwap")
return plots_to_add, legends, subplot_legends
import pandas as pd
import pandas_ta as TA
import numpy as np
import matplotlib.pyplot as plt
df = pd.read_csv('btcprice.csv')
rsi = TA.rsi(close=df['market-price'], length=30)
moving_rsi = TA.sma(close=rsi, length=30)
fft = np.fft.fft(moving_rsi)
fftfreq = np.fft.fftfreq(len(moving_rsi), d=len(moving_rsi))
plt.style.use('classic')
fig, ax = plt.subplots(3)
ax[0].plot(df['market-price'])
ax[1].plot(rsi)
ax[1].plot(moving_rsi)
ax[2].plot(fftfreq, fft)
plt.show()
def add_plots(df, ns_parser):
panel_number = 2
plots_to_add = []
legends = []
subplot_legends = []
if ns_parser.ad:
ad = ta.ad(df["High"], df["Low"], df["Close"], df["Volume"])
ad_plot = mpf.make_addplot(ad, panel=panel_number)
plots_to_add.append(ad_plot)
subplot_legends.extend([panel_number * 2, ["AD"]])
panel_number += 1
if ns_parser.bbands:
bbands = ta.bbands(df["Close"])
bbands = bbands.drop("BBB_5_2.0", axis=1)
bbands_plot = mpf.make_addplot(bbands, panel=0)
plots_to_add.append(bbands_plot)
legends.extend(["Lower BBand", "Middle BBand", "Upper BBand"])
if ns_parser.cci:
cci = ta.cci(df["High"], df["Low"], df["Close"])
cci_plot = mpf.make_addplot(cci, panel=panel_number)
plots_to_add.append(cci_plot)
subplot_legends.extend([panel_number * 2, ["CCI"]])
panel_number += 1
if ns_parser.ema:
ema = ta.ema(df["Close"])
ema_plot = mpf.make_addplot(ema, panel=0)
plots_to_add.append(ema_plot)
legends.append("10 EMA")
if ns_parser.rsi:
rsi = ta.rsi(df["Close"])
rsi_plot = mpf.make_addplot(rsi, panel=panel_number)
plots_to_add.append(rsi_plot)
subplot_legends.extend([panel_number * 2, ["RSI"]])
panel_number += 1
if ns_parser.obv:
obv = ta.obv(df["Close"], df["Volume"])
obv_plot = mpf.make_addplot(obv, panel=panel_number)
plots_to_add.append(obv_plot)
subplot_legends.extend([panel_number * 2, ["OBV"]])
panel_number += 1
if ns_parser.sma:
sma_length = [20, 50]
for length in sma_length:
sma = ta.sma(df["Close"], length=length)
sma_plot = mpf.make_addplot(sma, panel=0)
plots_to_add.append(sma_plot)
legends.append(f"{length} SMA")
if ns_parser.vwap:
vwap = ta.vwap(df["High"], df["Low"], df["Close"], df["Volume"])
vwap_plot = mpf.make_addplot(vwap, panel=0)
plots_to_add.append(vwap_plot)
legends.append("vwap")
return plots_to_add, legends, subplot_legends
def sma(l_args, s_ticker, s_interval, df_stock):
parser = argparse.ArgumentParser(
add_help=False,
prog="sma",
description="""
Moving Averages are used to smooth the data in an array to
help eliminate noise and identify trends. The Simple Moving Average is literally
the simplest form of a moving average. Each output value is the average of the
previous n values. In a Simple Moving Average, each value in the time period carries
equal weight, and values outside of the time period are not included in the average.
This makes it less responsive to recent changes in the data, which can be useful for
filtering out those changes.
""",
)
parser.add_argument(
"-l",
"--length",
dest="l_length",
type=lambda s: [int(item) for item in s.split(",")],
default=[20, 50],
help="length of MA window",
)
parser.add_argument(
"-o",
"--offset",
action="store",
dest="n_offset",
type=check_positive,
default=0,
help="offset",
)
try:
ns_parser = parse_known_args_and_warn(parser, l_args)
if not ns_parser:
return
plt.figure()
if s_interval == "1440min":
plt.plot(df_stock.index,
df_stock["5. adjusted close"].values,
color="k")
else:
plt.plot(df_stock.index, df_stock["4. close"].values, color="k")
l_legend = list()
l_legend.append(s_ticker)
for length in ns_parser.l_length:
if s_interval == "1440min":
df_ta = ta.sma(
df_stock["5. adjusted close"],
length=length,
offset=ns_parser.n_offset,
).dropna()
else:
df_ta = ta.sma(df_stock["4. close"],
length=length,
offset=ns_parser.n_offset).dropna()
plt.plot(df_ta.index, df_ta.values)
l_legend.append(f"{length} SMA")
plt.title(f"SMA on {s_ticker}")
plt.xlim(df_stock.index[0], df_stock.index[-1])
plt.xlabel("Time")
plt.ylabel("Share Price ($)")
plt.legend(l_legend)
plt.grid(b=True, which="major", color="#666666", linestyle="-")
plt.minorticks_on()
plt.grid(b=True,
which="minor",
color="#999999",
linestyle="-",
alpha=0.2)
plt.ion()
plt.show()
print("")
except Exception as e:
print(e)
print("")
from pandas_ta import vwma
from pandas_ta import sma
from pandas_ta import rsi
from pandas_ta import bbands
import torch
from torch import nn
from sklearn.preprocessing import MinMaxScaler
# importing training data sets
from torch.autograd import Variable
data_cleaned = pd.read_csv('data_cleaned.csv')
data_cleaned = data_cleaned.assign(slow_vwma_value=(vwma(data_cleaned.close, data_cleaned.volume, length=2, offset=0)),
fast_vwma_value=(vwma(data_cleaned.close, data_cleaned.volume, length=5, offset=0)),
slow_sma_value=(sma(data_cleaned.close, 15)),
fast_sma_value=(sma(data_cleaned.close, 5)),
rsi_data_value=(rsi(data_cleaned.close, 10)),
)
bbands_train = pd.DataFrame(bbands(data_cleaned.close, length=30, std=1.7))
data_cleaned = pd.concat([data_cleaned, bbands_train], axis=1)
# data_cleaned['timestamp'] = pd.to_datetime(data_cleaned['timestamp'], format='%Y-%m-%d %H')
data_cleaned = data_cleaned.set_index('timestamp')
data_cleaned = data_cleaned.dropna()
# print(data_cleaned)
# print(len(data_cleaned))
# importing test data sets
data_cleaned_test = pd.read_csv("data_cleaned_test.csv")
data_cleaned_test = data_cleaned_test.assign(
slow_vwma_value=(vwma(data_cleaned_test.close, data_cleaned_test.volume, length=15, offset=0)),
for symbol in barsets:
# print(f"processing symbol {symbol}")
recent_closes = [[bar.o, bar.h, bar.l, bar.c] for bar in barsets[symbol]]
_s = pd.DataFrame(recent_closes)
close_idx = 3
rsi, sma_20, sma_50 = None, None, None
for bar in barsets[symbol]:
good_date = date.today().isoformat() == bar.t.date().isoformat()
stock_id = stock_dict[symbol]
if len(_s) > 14 and good_date:
rsi = ta.rsi(_s[close_idx], lenght=14)
rsi = rsi.to_numpy()[-1]
sma_20 = ta.sma(_s[close_idx], length=20)
sma_20 = sma_20.to_numpy()[-1]
if len(_s) > 50 and good_date:
sma_50 = ta.sma(_s[close_idx], length=50)
sma_50 = sma_50.to_numpy()[-1]
cursor.execute(
"""
INSERT INTO stock_price (
stock_id, date, open, high, low, close, volume,
sma_20, sma_50, rsi_14)
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
""",
(
stock_id,
company_name = get_symbol(symbol.upper())
start = pd.to_datetime(start)
end = pd.to_datetime(end)
# Read data
data = yf.download(symbol, start, end)
# Adjusted Close Price
st.header(f"Adjusted Close Price\n {company_name}")
st.line_chart(data['Adj Close'])
# ## SMA and EMA
#Simple Moving Average
data['SMA'] = ta1.sma(data['Adj Close'], timeperiod=20)
# Exponential Moving Average
data['EMA'] = ta1.ema(data['Adj Close'], timeperiod=20)
# Plot
st.header(
f"Simple Moving Average vs. Exponential Moving Average\n {company_name}")
st.line_chart(data[['Adj Close', 'SMA', 'EMA']])
# Bollinger Bands
data[['lower_band',
'middle_band', 'upper_band']] = ta1.bbands(data['Adj Close'],
timeperiod=20).iloc[:, 0:3]
# Plot
print(f'{item} removed')
except KeyError:
print('The dictionary has no item now...')
break
# sma = a.sma # calculate smas
# insert into smaanalysistable data for 1 symbol, 2 symbol
# Daily
#get today date
#print(dict1)
data=pd.DataFrame.from_dict(dict1)
data['sma10']= ta.sma(data["CLOSE"], length=10,append=True)
#print(data)
data=pd.DataFrame.from_dict(dict1)
data['sma05']=data['CLOSE'].rolling(window=5).mean()
data['sma10']=data['CLOSE'].rolling(window=10).mean()
data['sma15']=data['CLOSE'].rolling(window=15).mean()
data['sma20']=data['CLOSE'].rolling(window=20).mean()
data['sma50']=data['CLOSE'].rolling(window=50).mean()
testdata=(data[['SYMBOL','SERIES','TIMESTAMP','CLOSE','sma05','sma10','sma15','sma15','sma20','sma50']])
rec=testdata.to_dict("records")
print(rec)
testdata.to_csv("final1121699.csv")
mycol1.insert_many(rec)
