def add_indicators(self):
#self.add_ema(9)
#self.add_ema(21)
#self.strategy = strategies.CustomStrategy(self.df['close'], self.df['ema9'], self.df['ema21'])
#return self.strategy
self.rsi = indicators.RSI(self.df['close'], 9)
self.macd = indicators.MACD(self.df['close'], 12, 26, 9)
def inputs(company, begin="2000-01-03", end=datetime.date.today()):
df = dataframe.get_data([company])
boll = indicators.bollinger_differential(company)
rsi = indicators.RSI(company)
oscillator = indicators.stochastic_oscillator(company)
input_set = df.join(boll.join(rsi))
return input_set[20:]
def test_RSI(self):
rsi = pd.read_csv('tests/data/BTCUSDT_15m_RSI9.csv',
index_col='time',
parse_dates=True)
myrsi = indicators.RSI(self.ohlc.close, period=9)
isclose = np.isclose(rsi.rsi.iloc[100:],
myrsi.df.rsi.iloc[100:],
equal_nan=True)
# consider first 100 values as warmup
self.assertTrue(np.all(isclose))
def drawRSI(ax, data, periods=[6, 12, 24], hlines=[20, 50, 80]):
for period in periods:
if data.__contains__('rsi%d' % period):
rsi = data['rsi%d' % period]
elif data.__contains__('rsi'):
rsi = data['rsi']
else:
price = data['close']
rsi = ind.RSI(price, time_period=period)
ax.plot(rsi, label='rsi%d' % period)
drawHline(ax, hlines)
ax.set_ylabel('RSI')
def test_RSI(self):
rsi = indicators.RSI(self.ohlc.close, period=9)
strategy = strategies.RSIStrategy(self.ohlc, rsi)
result = strategy.backtest(self.ohlc.close)
self.assertEqual(result.start, datetime(2020, 1, 8, 1, 30, 0))
self.assertEqual(result.end, datetime(2020, 1, 18, 11, 15, 0))
self.assertEqual(result.trades, 11)
self.assertTrue(math.isclose(result.netret, 12.81, rel_tol=1e-02))
self.assertTrue(math.isclose(result.sharpe, 0.1164, rel_tol=1e-03))
self.assertTrue(math.isclose(result.maxdrawdown, -4.0, rel_tol=1e-02))
self.assertEqual(result.maxdrawdownduration, 174)
def test_RSI_MACD(self):
rsi = indicators.RSI(self.ohlc.close, period=9)
macd = indicators.MACD(self.ohlc.close, 12, 26, 9)
strategy = strategies.RSIMACDStrategy(self.ohlc, rsi, macd)
result = strategy.backtest(self.ohlc.close)
self.assertEqual(result.start, datetime(2020, 1, 8, 1, 30, 0))
self.assertEqual(result.end, datetime(2020, 1, 18, 11, 15, 0))
self.assertEqual(result.trades, 41)
self.assertTrue(math.isclose(result.netret, 26.06, rel_tol=1e-02))
self.assertTrue(math.isclose(result.sharpe, 0.1297, rel_tol=1e-03))
self.assertTrue(math.isclose(result.maxdrawdown, -2.85, rel_tol=1e-02))
self.assertEqual(result.maxdrawdownduration, 82)
def _indicators(self):
""" This will calculate our technical indicators based on the
parameters in our ti dict ... this can be ran in one bang OR
iteratively. It goes directly to the indicator structs. Not pretty,
but what the f**k.
"""
# TODO: update this if we ever want to add multiple OHLC frames
for time_str in self.ohlc:
for indicator in self.ti:
if indicator == "RSI":
self.ti[indicator]["data"] = ind.RSI(
self.ohlc[time_str], self.ti[indicator]["n"])
elif indicator == "ROC":
self.ti[indicator]["data"] = ind.ROC(
self.ohlc[time_str], self.ti[indicator]["n"])
elif indicator == "AMA":
self.ti[indicator]["data"] = ind.AMA(
self.ohlc[time_str].close, self.ti[indicator]["n"],
self.ti[indicator]["fn"], self.ti[indicator]["sn"])
elif indicator == "CCI":
self.ti[indicator]["data"] = ind.CCI(
self.ohlc[time_str], self.ti[indicator]["n"])
elif indicator == "FRAMA":
self.ti[indicator]["data"] = ind.FRAMA(
self.ohlc[time_str], self.ti[indicator]["n"])
elif indicator == "RVI2":
self.ti[indicator]["data"] = ind.RVI2(
self.ohlc[time_str], self.ti[indicator]["n"],
self.ti[indicator]["s"])
elif indicator == "MACD":
self.ti[indicator]["data"] = ind.MACD(
self.ohlc[time_str], self.ti[indicator]["f"],
self.ti[indicator]["s"], self.ti[indicator]["m"])
elif indicator == "ADX":
self.ti[indicator]["data"] = ind.ADX(
self.ohlc[time_str], self.ti[indicator]["n"])
elif indicator == "ELI":
self.ti[indicator]["data"] = ind.ELI(
self.ohlc[time_str], self.ti[indicator]["n"])
elif indicator == "TMI":
self.ti[indicator]["data"] = ind.TMI(
self.ohlc[time_str], self.ti[indicator]["nb"],
self.ti[indicator]["nf"])
def main():
parser = argparse.ArgumentParser()
parser.add_argument("file")
parser.add_argument("--sma", type=int, nargs='+', help='Adds SMA to the price graph')
parser.add_argument("--ema", type=int, nargs='+', help='Adds EMA to the price graph')
parser.add_argument("--rsi", type=int, help='Adds RSI in a subplot')
parser.add_argument("--macd", type=int, nargs=3, help='Adds MACD in a subplot')
parser.add_argument("--bbands", type=int, nargs=2, help='Adds Bollinger Bands to the price graph')
parser.add_argument("--strategy", type=int, nargs='+', help='Adds a strategy, 1 : EMA Cross')
args = parser.parse_args()
ohlc = pd.read_csv(args.file, index_col='time', parse_dates=True)
close = ohlc['close']
# calculates the number of sublots
rows = 1
if args.rsi != None:
rows += 1
if args.macd != None:
rows += 1
fig = make_subplots(rows=rows, cols=1, shared_xaxes=True)
# plots close bar graph with averages
row = 1
fig.add_trace(go.Scatter(x=ohlc.index, y=close, name="Close"), row=row, col=1)
if args.ema != None:
for period in args.ema:
ema = indicators.EMA(close, period)
fig.add_trace(go.Scatter(x=ohlc.index, y=ema.df['ema{}'.format(period)], name="EMA {}".format(period)), row=row, col=1)
if args.sma != None:
for period in args.sma:
sma = indicators.SMA(close, period)
fig.add_trace(go.Scatter(x=ohlc.index, y=sma.df['sma{}'.format(period)], name="SMA {}".format(period)), row=row, col=1)
# plots Bollinger Bands
if args.bbands != None:
bbands = indicators.BollingerBands(close, args.bbands[0])
fig.add_trace(go.Scatter(x=ohlc.index, y=bbands.df.ma), row=row, col=1)
fig.add_trace(go.Scatter(x=ohlc.index, y=bbands.df.upper), row=row, col=1)
fig.add_trace(go.Scatter(x=ohlc.index, y=bbands.df.lower), row=row, col=1)
row += 1
row += 1
# plots RSI
if args.rsi != None:
rsi = indicators.RSI(close, args.rsi)
fig.add_trace(go.Scatter(x=ohlc.index, y=rsi.df.rsi, name="RSI {}".format(args.rsi)), row=row, col=1)
row += 1
# plots MACD
if args.macd != None:
macd = indicators.MACD(close, args.macd[0], args.macd[1], args.macd[2])
fig.add_trace(go.Scatter(x=ohlc.index, y=macd.df.MACD, name="MACD {} {} {}".format(args.macd[0], args.macd[1], args.macd[2])), row=row, col=1)
fig.add_trace(go.Scatter(x=ohlc.index, y=macd.df.signal, name="MACD Signal"), row=row, col=1)
row += 1
# plots strategy
if args.strategy != None:
if args.strategy[0] == 1:
fast_ema = indicators.EMA(ohlc.close, period=args.strategy[1])
slow_ema = indicators.EMA(ohlc.close, period=args.strategy[2])
strategy = strategies.AvgCrossStrategy(ohlc.close, fast_ema.data(), slow_ema.data())
fig.add_trace(go.Scatter(x=close.loc[strategy.signals['positions'] == 1.0].index, y=close.loc[strategy.signals['positions'] == 1.0],
mode='markers', marker=dict(size=12, symbol='triangle-up', color='green'), name="Buy"), row=1, col=1)
fig.add_trace(go.Scatter(x=close.loc[strategy.signals['positions'] == -1.0].index, y=close.loc[strategy.signals['positions'] == -1.0],
mode='markers', marker=dict(size=12, symbol='triangle-down', color='red'), name="Sell"), row=1, col=1)
elif args.strategy[0] == 2:
macd = indicators.MACD(ohlc.close, args.strategy[1], args.strategy[2], args.strategy[3])
strategy = strategies.MACDStrategy(ohlc.close, macd)
fig.add_trace(go.Scatter(x=close.loc[strategy.signals['positions'] == 1.0].index, y=close.loc[strategy.signals['positions'] == 1.0],
mode='markers', marker=dict(size=12, symbol='triangle-up', color='green'), name="Buy"), row=1, col=1)
fig.add_trace(go.Scatter(x=close.loc[strategy.signals['positions'] == -1.0].index, y=close.loc[strategy.signals['positions'] == -1.0],
mode='markers', marker=dict(size=12, symbol='triangle-down', color='red'), name="Sell"), row=1, col=1)
elif args.strategy[0] == 3:
bb1 = indicators.BollingerBands(ohlc.close, 20, 1)
bb2 = indicators.BollingerBands(ohlc.close, 20, 2)
strategy = strategies.DBBStrategy(ohlc.close, bb1, bb2)
fig.add_trace(go.Scatter(x=close.loc[strategy.signals['positions'] == 1.0].index, y=close.loc[strategy.signals['positions'] == 1.0],
mode='markers', marker=dict(size=12, symbol='triangle-up', color='green'), name="Buy"), row=1, col=1)
fig.add_trace(go.Scatter(x=close.loc[strategy.signals['positions'] == -1.0].index, y=close.loc[strategy.signals['positions'] == -1.0],
mode='markers', marker=dict(size=12, symbol='triangle-down', color='red'), name="Sell"), row=1, col=1)
elif args.strategy[0] == 4:
rsi = indicators.RSI(ohlc.close, 9)
macd = indicators.MACD(ohlc.close, 12, 26, 9)
strategy = strategies.RSIMACDStrategy(ohlc.close, rsi, macd)
fig.add_trace(go.Scatter(x=close.loc[strategy.signals['positions'] == 1.0].index, y=close.loc[strategy.signals['positions'] == 1.0],
mode='markers', marker=dict(size=12, symbol='triangle-up', color='green'), name="Buy"), row=1, col=1)
fig.add_trace(go.Scatter(x=close.loc[strategy.signals['positions'] == -1.0].index, y=close.loc[strategy.signals['positions'] == -1.0],
mode='markers', marker=dict(size=12, symbol='triangle-down', color='red'), name="Sell"), row=1, col=1)
fig.show()
# ATR Channels:
ATRChannels26 = ind.ATRChannels(window_length=26, time_frame=time_frame)
print('Fitting ATR Channels...')
ATRChannels26.batch_fit(candles)
# Bollinger band:
print('Fitting Bollinger Bands...')
BB20 = ind.BollingerBand(window_length=80,
time_frame=time_frame,
tp_style='hlc3')
BB20.batch_fit(candles)
# RSI:
print('Fitting RSI...')
RSI = ind.RSI(window_length=14, time_frame=time_frame)
RSI.batch_fit(candles)
# Stochastic RSI:
print('Fitting Stochastic RSI...')
SRSI = ind.StochasticRSI(stoch_length=14, time_frame=time_frame)
SRSI.batch_fit(candles)
# MACD:
print('Fitting MACD...')
MACD = ind.MACD(12, 26, 9, time_frame, 'close')
MACD.batch_fit(candles)
""" Making plots using Plotly """
print('\nPlotting...')
fig = make_subplots(
rows=5,
def main():
parser = argparse.ArgumentParser()
parser.add_argument("file")
args = parser.parse_args()
df = pd.read_csv(args.file, index_col='time', parse_dates=True)
#close = df.loc['20191225':,['close']].astype('float64')
close = df
print("Buy And Hold Strategy :")
strat1 = strategies.BuyAndHoldStrategy(close, 0.001)
res = strat1.backtest(close['close'])
print(res)
print(flush=True)
add_ema(close, 12)
add_ema(close, 26)
macd = indicators.MACD(close['close'], 12, 26, 9)
rsi = indicators.RSI(close['close'], 9)
bb1 = indicators.BollingerBands(close['close'], 20, 1)
bb2 = indicators.BollingerBands(close['close'], 20, 2)
print("MACD Strategy :")
strat3 = strategies.MACDStrategy(close, macd, 0.001)
res = strat3.backtest(close['close'])
print(res)
print(flush=True)
print("RSI Strategy :")
strat4 = strategies.RSIStrategy(close, rsi, 0.001)
res = strat4.backtest(close['close'])
print(res)
print(flush=True)
print("Double Bollinger Bands Strategy :")
strat5 = strategies.DBBStrategy(close['close'], bb1, bb2)
res = strat5.backtest(close['close'])
print(res)
print(flush=True)
print("Custom RSI + MACD Strategy :")
strat2 = strategies.RSIMACDStrategy(close, rsi, macd, 0.001)
res = strat2.backtest(close['close'])
print(res)
fig, (ax1, ax2, ax3, ax4) = plt.subplots(4, sharex=True)
fig.suptitle(args.file)
ax1.plot(close['close'])
ax1.plot(close['ema12'], label='EMA12')
ax1.plot(close['ema26'], label='EMA26')
ax1.plot(close['close'].loc[strat2.signals['positions'] == 1.0].index,
close['close'].loc[strat2.signals['positions'] == 1.0],
'^',
markersize=10,
color='g')
ax1.plot(close['close'].loc[strat2.signals['positions'] == -1.0].index,
close['close'].loc[strat2.signals['positions'] == -1.0],
'v',
markersize=10,
color='r')
ax1.legend()
macd, macd_signal = macd.data()
ax2.plot(macd, label='MACD 12 26 9')
ax2.plot(macd_signal)
#ax3.plot(strat1.signals['equity'])
ax3.plot(rsi.data(), label='RSI 9')
ax4.plot(strat2.signals['equity'])
plt.show()
print('')
print('Period with best Neig_SQN: %i' %
self.eventsRelevantData['Period with best Neig_SQN'])
print('SQN of period with best Neig_SQN: %0.3f' %
self.eventsRelevantData['Best Neig_SQN'])
print('Sharpe of period with best Neig_SQN: %0.3f' %
self.eventsRelevantData['Sharpe of period with best Neig_SQN'])
print('RSQN of period with best Neig_SQN: %0.3f' %
self.eventsRelevantData['RSQN of period with best Neig_SQN'])
print('Mean of period with best Neig_SQN: %0.3f' %
self.eventsRelevantData['Mean of period with best Neig_SQN'])
print('')
#print('Commission costs')
print('Order type: %s' % self.orderType)
print('')
if __name__ == "__main__":
"""
"""
import indicators
import datetime as dt
endDate = dt.date(2016, 12, 31)
startDate = endDate - dt.timedelta(365 * 5)
RSI = indicators.RSI('EURCAD', 'H4', startDate=startDate, endDate=endDate)
RSI.break_level(70)
s = StrategyCreator('EURCAD', 'H4', indicatorsList=[RSI], commission=20)
s.generate_optimized_event_study(occurrenceNumber=1, lookback=20)
import database_tools as dt
import indicators
import datetime
print "standard_deviation " + str(
indicators.standard_deviation("TXT", datetime.datetime.today(), 10))
print "simple_moving_average " + str(
indicators.SMA("TXT", datetime.datetime.today(), 10))
print "volatility " + str(
indicators.volatility("TXT", datetime.datetime.today(), 10))
print "WilliamsR " + str(
indicators.willamsR("TXT", datetime.datetime.today(), 10))
print "RSI " + str(indicators.RSI("TXT", datetime.datetime.today(), 10))
print "average_true_range " + str(
indicators.ATR("TXT", datetime.datetime.today(), 10))
print "EMA " + str(indicators.EMA("TXT", datetime.datetime.today(), 10))
print "bollinger_bands_customized " + str(
indicators.bollinger_bands_customized("TXT", datetime.datetime.today(),
10))
strat = Strategy('EURUSD', 'M15', 'BUY', commission = 15, swap=(-5,-9),
indicatorsList = [sma, rsi])
strat.generate_optimized_event_study(eventwindow=(-100, 500),
commission = True, swap=True)
#strat.plot_all_events(showExamples = 50, commission=True)
print(strat.signalsSpan)
print('')
print(strat.eventsRelevantData)
print('')
print(strat.orderType)
print('')
print(strat.eventsNum)
"""
indicator = indicators.RSI('EURUSD', 'H1', 14, forceCalculation=False)
indicator.filter_indicator(70, method='above')
# strategy = Strategy('EURUSD', 'H1', 'BUY', commission = 15, swap=(-5,-9),
# indicatorsList = [indicator])
# strategy.generate_optimized_event_study(eventwindow=(-100, 500),
# commission = True, swap=True,
# plot=True)
# optimization[v] = strategy
#
#for k in np.sort(optimization.keys()):
# optimization[k].plot_all_events(commission=True)
# print(optimization[k].eventsRelevantData)
# print(optimization[k].orderType)
# print(optimization[k].signalsSpan)
"""