def handle_data(self, data): # overload handle_data() method
#print self.day_count
date = TradingAlgorithm.get_datetime(self)
self.dates.append(date)
#print self.portfolio
#print str(date)[0:10]
# Get price and trend data
for sym in sym_list:
#print self.portfolio
# Price
sym_price = data[sym].price
sym_high = data[sym].high
sym_low = data[sym].low
sym_volume = data[sym].volume
self.prices[sym] = np.append(self.prices[sym],sym_price)
self.lows[sym] = np.append(self.prices[sym],sym_low)
self.highs[sym] = np.append(self.prices[sym],sym_high)
# Volume
self.volume[sym] = np.append(self.volume[sym],sym_volume)
# RSI, MACD, Chaikin, MFI
mfi = self.get_mfi(sym)
cmf = self.get_chaikin(sym)
self.chaikin_plot[sym] = np.append(self.chaikin_plot[sym],cmf)
rsi = self.get_rsi(sym)[-1]
self.rsi_plot[sym] = np.append(self.rsi_plot[sym],rsi)
macd, macdsignal, macdhist = self.get_macd(sym)
# Trend
trend = self.trend_dfs[sym]['sum'][self.dates[-1]]
self.trends[sym].append(float(trend))
# Get gains
gain = self.trade_gain(sym)
self.gains[sym] = np.append(self.gains[sym],gain)
# Get RS and zscore
if self.day_count >= window_long:
rs = self.get_rs
zscore = self.trend_zscore(sym,date,window_long)
zscore_s = self.trend_zscore(sym,date,window_short)
self.zscores[sym].append(zscore)
self.zscores_s[sym].append(zscore_s)
# Execute trades
if self.portfolio.positions[sym].amount == 0 and self.zscores[sym][-1] >= 2 and mfi > 40: # cmf > -0.1 and :# and rsi <= 30: # and cmf > -0.05:
#if self.zscores_s[sym][-1] > self.zscores[sym][-1] and self.zscores_s[sym][-2] < self.zscores[sym][-2]:
if 1 == 1:
self.long(data,sym)
print str(date)[0:10],'LONG:',sym
elif self.portfolio.positions[sym].amount != 0:
if sym_price >= self.atr_plot[sym]['profit'][-1] or sym_price <= self.atr_plot[sym]['loss'][-1]:
q = self.portfolio.positions[sym].amount
self.order(sym,-q)
print str(date)[0:10],'Exit:',sym
else:
self.zscores[sym].append(0)
self.zscores_s[sym].append(0)
atr = self.get_atr(sym)[-1]
self.atr_plot[sym]['profit'].append((atr*3)+sym_price)
self.atr_plot[sym]['loss'].append(-(atr*3)+sym_price)
self.day_count += 1
def handle_data(self, data): # overload handle_data() method
day = TradingAlgorithm.get_datetime(self)
self.dates.append(day)
#print self.day_count
#print self.portfolio
# Get price data
for sym in sym_list:
sym_price = data[sym].price
sym_high = data[sym].high
sym_low = data[sym].low
self.prices[sym] = np.append(self.prices[sym], sym_price)
self.lows[sym] = np.append(self.prices[sym], sym_low)
self.highs[sym] = np.append(self.prices[sym], sym_high)
# Execute trades
for sym in sym_list:
if self.day_count >= 0:
atr = self.get_atr(sym)[-1]
rsi = self.get_rsi(sym)[-1]
macd, macdsignal, macdhist = self.get_macd(sym)
slowk, slowd = self.get_stoch(sym)
#
if self.portfolio.positions[sym].amount == 0:
if macd[-1] > 0 and rsi > 70 and 50 <= slowk[-1] <= 80:
print day, ' Long ', sym
self.long(data, sym)
self.buy_plot[sym].append(self.day_count)
take = (atr * 5) + sym_price
stop = -(atr * 2) + sym_price
self.stops[sym] = [take, stop]
elif macd[-1] < 0 and rsi < 30 and 20 <= slowk[-1] <= 50:
print day, ' Short ', sym
self.short(data, sym)
self.sell_plot[sym].append(self.day_count)
take = -(atr * 5) + sym_price
stop = (atr * 2) + sym_price
self.stops[sym] = [take, stop]
else:
pass
elif self.portfolio.positions[sym].amount > 0:
if sym_price >= self.stops[sym][
0] or sym_price <= self.stops[sym][1]:
print day, ' Exit Long ', sym
q = self.portfolio.positions[sym].amount
self.order(sym, -q)
self.sell_plot[sym].append(self.day_count)
elif self.portfolio.positions[sym].amount < 0:
if sym_price <= self.stops[sym][
0] or sym_price >= self.stops[sym][1]:
print day, ' Exit Short ', sym
q = self.portfolio.positions[sym].amount
self.order(sym, -q)
self.buy_plot[sym].append(self.day_count)
self.day_count += 1
def handle_data(self, data): # overload handle_data() method
day = TradingAlgorithm.get_datetime(self)
self.dates.append(day)
#print self.day_count
#print self.portfolio
# Get price data
for sym in sym_list:
sym_price = data[sym].price
sym_high = data[sym].high
sym_low = data[sym].low
self.prices[sym] = np.append(self.prices[sym],sym_price)
self.lows[sym] = np.append(self.prices[sym],sym_low)
self.highs[sym] = np.append(self.prices[sym],sym_high)
# Execute trades
for sym in sym_list:
if self.day_count >= 0:
atr = self.get_atr(sym)[-1]
rsi = self.get_rsi(sym)[-1]
macd, macdsignal, macdhist = self.get_macd(sym)
slowk, slowd = self.get_stoch(sym)
#
if self.portfolio.positions[sym].amount == 0:
if macd[-1] > 0 and rsi > 70 and 50 <= slowk[-1] <= 80:
print day,' Long ',sym
self.long(data,sym)
self.buy_plot[sym].append(self.day_count)
take = (atr*5)+sym_price
stop = -(atr*2)+sym_price
self.stops[sym] = [take,stop]
elif macd[-1] < 0 and rsi < 30 and 20 <= slowk[-1] <= 50:
print day,' Short ',sym
self.short(data,sym)
self.sell_plot[sym].append(self.day_count)
take = -(atr*5)+sym_price
stop = (atr*2)+sym_price
self.stops[sym] = [take,stop]
else:
pass
elif self.portfolio.positions[sym].amount > 0:
if sym_price >= self.stops[sym][0] or sym_price <= self.stops[sym][1]:
print day,' Exit Long ',sym
q = self.portfolio.positions[sym].amount
self.order(sym,-q)
self.sell_plot[sym].append(self.day_count)
elif self.portfolio.positions[sym].amount < 0:
if sym_price <= self.stops[sym][0] or sym_price >= self.stops[sym][1]:
print day,' Exit Short ',sym
q = self.portfolio.positions[sym].amount
self.order(sym,-q)
self.buy_plot[sym].append(self.day_count)
self.day_count += 1
def handle_data(self, data): # overload handle_data() method
#print self.day_count
date = TradingAlgorithm.get_datetime(self)
self.dates.append(date)
#print self.portfolio
#print str(date)[0:10]
# Get price and trend data
for sym in sym_list:
# Price
sym_price = data[sym].price
sym_high = data[sym].high
sym_low = data[sym].low
self.prices[sym] = np.append(self.prices[sym], sym_price)
self.lows[sym] = np.append(self.prices[sym], sym_low)
self.highs[sym] = np.append(self.prices[sym], sym_high)
# RSI, MACD
rsi = self.get_rsi(sym)[-1]
macd, macdsignal, macdhist = self.get_macd(sym)
# Trend
trend = self.trend_df[sym][self.dates[-1]]
self.trends[sym].append(float(trend))
# Get RS and zscore
if self.day_count >= window:
rs = self.get_rs
zscore = self.trend_zscore(sym, date)
self.zscores[sym].append(zscore)
# Execute trades
if self.portfolio.positions[sym].amount == 0 and zscore >= 3:
self.long(data, sym)
print str(date)[0:10], 'LONG:', sym
elif self.portfolio.positions[sym].amount != 0:
if sym_price >= self.atr_plot[sym]['profit'][
-1] or sym_price <= self.atr_plot[sym]['loss'][-1]:
q = self.portfolio.positions[sym].amount
self.order(sym, -q)
print str(date)[0:10], 'Exit:', sym
else:
self.zscores[sym].append(0)
atr = self.get_atr(sym)[-1]
self.atr_plot[sym]['profit'].append((atr * 3) + sym_price)
self.atr_plot[sym]['loss'].append(-(atr * 1.5) + sym_price)
self.day_count += 1
def place_orders(self, data, sym, etf, sym_price, etf_price, zscore):
####################################################################
day = TradingAlgorithm.get_datetime(self)
# Buy spread if z-score is > 2, sell if z-score < .5.
etf = sym_list[sym]
sym_price = data[sym].price
etf_price = data[etf].price
if zscore >= 2 and self.portfolio.positions[sym].amount == 0:
sym_quantity = -int(trade_size / sym_price)
etf_quantity = int(trade_size / etf_price)
self.order(sym, sym_quantity)
self.order(etf, etf_quantity)
self.trade_log[sym] = self.trade_log[sym] + 1
action = 'SELL'
self.set_log(day, sym, etf, zscore, action,
(sym_price - etf_price))
elif zscore <= -2 and self.portfolio.positions[sym].amount == 0:
sym_quantity = int(trade_size / sym_price)
etf_quantity = -int(trade_size / etf_price)
self.order(sym, sym_quantity)
self.order(etf, etf_quantity)
self.trade_log[sym] = self.trade_log[sym] + 1
action = 'BUY'
self.set_log(day, sym, etf, zscore, action,
(sym_price - etf_price))
elif abs(zscore) < .5 and self.portfolio.positions[sym].amount != 0:
etf_amount = self.portfolio.positions[etf].amount
self.order(etf, -1 * etf_amount)
sym_amount = self.portfolio.positions[sym].amount
self.order(sym, -1 * sym_amount)
if sym_amount > 0:
action = 'SELL'
self.set_log(day, sym, etf, zscore, action,
(sym_price - etf_price))
else:
action = 'BUY'
self.set_log(day, sym, etf, zscore, action,
(sym_price - etf_price))
else:
action = '---'
self.actions[sym]['ACTION'].append(action)
return
def handle_data(self, data):
####################################################################
day = TradingAlgorithm.get_datetime(self)
self.dates.append(day)
print self.dates[-1]
#print 'Progress: ' + str(PerformanceTracker.to_dict(self))
####################################################################
# Get the prices and do some calculations
for sym in sym_list:
etf = sym_list[sym]
sym_price = data[sym].price
etf_price = data[etf].price
ratio = sym_price - etf_price
self.trade_return(sym, ratio)
self.ratios[sym]['SPREAD'].append(ratio)
####################################################################
# Calculate the trade return for analysis purposes
####################################################################
# Trade related calculations loop
self.day_count += 1
for sym in sym_list:
etf = sym_list[sym]
sym_price = data[sym].price
etf_price = data[etf].price
################################################################
# 1. Compute regression coefficients between the two instruments
params = self.ols_transform.handle_data(data, sym, etf)
if params is None: # Exits before
for sym in sym_list: # place_orders
self.zscores[sym]['ZSCORE'].append(0)
action = '---'
self.actions[sym]['ACTION'].append(action)
return
intercept, slope = params
################################################################
# 2. Compute spread and z-score
zscore = self.compute_zscore(data, sym, etf, sym_price, etf_price,
slope, intercept)
################################################################
# 3. Place orders
self.place_orders(data, sym, etf, sym_price, etf_price, zscore)
def handle_data(self, data): # overload handle_data() method
print self.day_count
print self.portfolio
month = int(str(TradingAlgorithm.get_datetime(self))[5:7])
# Get price data
spy_price = data[index].price
self.prices[index].append(spy_price)
for sym in sym_list:
sym_price = data[sym].price
self.prices[sym].append(sym_price)
# Execute trades
if len(self.dates) < spy_window or len(self.dates) < window:
pass
else:
spySMA = self.spy_sma()
if self.last_order == 0 or self.day_count >= self.last_order+22:
# Exit existing positions
for sym in feed:
if self.portfolio.positions[sym].amount != 0:
q = self.portfolio.positions[sym].amount
self.order(sym,-q)
if spy_price > spySMA:
# Enter new position
self.get_rs(data)
sorted_rs = sorted(self.rs_list.iteritems(), key=operator.itemgetter(1))
print sorted_rs
#print 'SHORT: ', sorted_rs[0][0], sorted_rs[1][0], sorted_rs[2][0]
#print 'LONG: ', sorted_rs[-3][0], sorted_rs[-2][0], sorted_rs[-1][0]
#self.short(data,sorted_rs[0][0])
#self.short(data,'SPY')
#self.short(data,sorted_rs[1][0])
#self.short(data,sorted_rs[2][0])
self.long(data,sorted_rs[-1][0])
self.long(data,sorted_rs[-2][0])
#self.long(data,sorted_rs[-3][0])
self.last_order = self.day_count
else:
pass
else:
pass
self.dates.append(month)
self.day_count += 1
def handle_data(self, data): # overload handle_data() method
#print self.day_count
date = TradingAlgorithm.get_datetime(self)
self.dates.append(date)
#print self.portfolio
#print str(date)[0:10]
# Get price and trend data
for sym in sym_list:
# Price
sym_price = data[sym].price
sym_high = data[sym].high
sym_low = data[sym].low
self.prices[sym] = np.append(self.prices[sym],sym_price)
self.lows[sym] = np.append(self.prices[sym],sym_low)
self.highs[sym] = np.append(self.prices[sym],sym_high)
# RSI, MACD
rsi = self.get_rsi(sym)[-1]
macd, macdsignal, macdhist = self.get_macd(sym)
# Trend
trend = self.trend_df[sym][self.dates[-1]]
self.trends[sym].append(float(trend))
# Get RS and zscore
if self.day_count >= window:
rs = self.get_rs
zscore = self.trend_zscore(sym,date)
self.zscores[sym].append(zscore)
# Execute trades
if self.portfolio.positions[sym].amount == 0 and zscore >= 3:
self.long(data,sym)
print str(date)[0:10],'LONG:',sym
elif self.portfolio.positions[sym].amount != 0:
if sym_price >= self.atr_plot[sym]['profit'][-1] or sym_price <= self.atr_plot[sym]['loss'][-1]:
q = self.portfolio.positions[sym].amount
self.order(sym,-q)
print str(date)[0:10],'Exit:',sym
else:
self.zscores[sym].append(0)
atr = self.get_atr(sym)[-1]
self.atr_plot[sym]['profit'].append((atr*3)+sym_price)
self.atr_plot[sym]['loss'].append(-(atr*1.5)+sym_price)
self.day_count += 1
def handle_data(self, data):
####################################################################
day = TradingAlgorithm.get_datetime(self)
self.dates.append(day)
print self.dates[-1]
#print 'Progress: ' + str(PerformanceTracker.to_dict(self))
####################################################################
# Get the prices and do some calculations
for sym in sym_list:
etf = sym_list[sym]
sym_price = data[sym].price
etf_price = data[etf].price
ratio = sym_price - etf_price
self.trade_return(sym, ratio)
self.ratios[sym]['SPREAD'].append(ratio)
####################################################################
# Calculate the trade return for analysis purposes
####################################################################
# Trade related calculations loop
self.day_count += 1
for sym in sym_list:
etf = sym_list[sym]
sym_price = data[sym].price
etf_price = data[etf].price
################################################################
# 1. Compute regression coefficients between the two instruments
params = self.ols_transform.handle_data(data, sym, etf)
if params is None: # Exits before
for sym in sym_list: # place_orders
self.zscores[sym]['ZSCORE'].append(0)
action = '---'
self.actions[sym]['ACTION'].append(action)
return
intercept, slope = params
################################################################
# 2. Compute spread and z-score
zscore = self.compute_zscore(data, sym, etf, sym_price, etf_price, slope, intercept)
################################################################
# 3. Place orders
self.place_orders(data, sym, etf, sym_price, etf_price, zscore)
def handle_data(self, data): # overload handle_data() method
day = TradingAlgorithm.get_datetime(self)
self.dates.append(day)
#print self.day_count
#print self.portfolio
# Get price data
for sym in sym_list:
sym_price = data[sym].price
self.prices[sym] = np.append(self.prices[sym],sym_price)
# Execute trades
for sym in sym_list:
if self.day_count >= 30:
rsi = self.get_rsi(sym)[-1]
trending = self.get_vratio(sym)
t = self.get_ttest(sym)
rs = self.get_rs(sym)
#
if self.portfolio.positions[sym].amount == 0:
if trending == True and t == True and rs > 0 and rsi < 70:
print day,' Long ',sym
self.long(data,sym)
self.buy_plot[sym].append(self.day_count)
elif trending == True and t == True and rs < 0 and rsi > 30:
print day,' Short ',sym
self.short(data,sym)
self.sell_plot[sym].append(self.day_count)
else:
pass
elif self.portfolio.positions[sym].amount > 0 and rsi >70:
print day,' Exit Long ',sym
q = self.portfolio.positions[sym].amount
self.order(sym,-q)
self.sell_plot[sym].append(self.day_count)
elif self.portfolio.positions[sym].amount < 0 and rsi < 30:
print day,' Exit Short ',sym
q = self.portfolio.positions[sym].amount
self.order(sym,-q)
self.buy_plot[sym].append(self.day_count)
else:
self.vratio_plot[sym] = np.append(self.vratio_plot[sym],0)
self.day_count += 1
def place_orders(self, data, sym, etf, sym_price, etf_price, zscore):
####################################################################
day = TradingAlgorithm.get_datetime(self)
# Buy spread if z-score is > 2, sell if z-score < .5.
etf = sym_list[sym]
sym_price = data[sym].price
etf_price = data[etf].price
if zscore >= 2 and self.portfolio.positions[sym].amount == 0:
sym_quantity = -int(trade_size / sym_price)
etf_quantity = int(trade_size / etf_price)
self.order(sym, sym_quantity)
self.order(etf, etf_quantity)
self.trade_log[sym] = self.trade_log[sym] + 1
action = 'SELL'
self.set_log(day, sym, etf, zscore, action, (sym_price-etf_price))
elif zscore <= -2 and self.portfolio.positions[sym].amount == 0:
sym_quantity = int(trade_size / sym_price)
etf_quantity = -int(trade_size / etf_price)
self.order(sym, sym_quantity)
self.order(etf, etf_quantity)
self.trade_log[sym] = self.trade_log[sym] + 1
action = 'BUY'
self.set_log(day, sym, etf, zscore, action, (sym_price-etf_price))
elif abs(zscore) < .5 and self.portfolio.positions[sym].amount != 0:
etf_amount = self.portfolio.positions[etf].amount
self.order(etf, -1 * etf_amount)
sym_amount = self.portfolio.positions[sym].amount
self.order(sym, -1 * sym_amount)
if sym_amount > 0:
action = 'SELL'
self.set_log(day, sym, etf, zscore, action, (sym_price-etf_price))
else:
action = 'BUY'
self.set_log(day, sym, etf, zscore, action, (sym_price-etf_price))
else:
action = '---'
self.actions[sym]['ACTION'].append(action)
return
