def run_bollinger_study(dt_start, dt_end, symbol_list, name, benchmark_sym, lookback):
ldt_timestamps = du.getNYSEdays(dt_start, dt_end, dt.timedelta(hours=16))
dataobj = da.DataAccess('Yahoo')
ls_symbols = dataobj.get_symbols_from_list(symbol_list)
ls_symbols.append('SPY')
ls_keys = ['open', 'high', 'low', 'close', 'volume', 'actual_close']
ldf_data = dataobj.get_data(ldt_timestamps, ls_symbols, ls_keys)
d_data = dict(zip(ls_keys, ldf_data))
for s_key in ls_keys:
d_data[s_key] = d_data[s_key].fillna(method='ffill')
d_data[s_key] = d_data[s_key].fillna(method='bfill')
d_data[s_key] = d_data[s_key].fillna(1.0)
df_events, ls_orders = find_events(ls_symbols, d_data, benchmark_sym, lookback)
print "Creating Study"
ep.eventprofiler(df_events, d_data, i_lookback=20, i_lookforward=20,
s_filename=name + '.pdf', b_market_neutral=True, b_errorbars=True,
s_market_sym='SPY')
print "Writing orders"
with open(name + '_orders.csv', 'w') as f:
writer = csv.writer(f)
for order in ls_orders:
writer.writerow(order)
def study(dt_start, dt_end, list, key, filename, limit, days, output, times):
ldt_timestamps = du.getNYSEdays(dt_start, dt_end, dt.timedelta(hours=16))
dataobj = da.DataAccess("Yahoo")
ls_symbols = dataobj.get_symbols_from_list(list)
ls_symbols.append("SPY")
ls_keys = ["open", "high", "low", "close", "volume", "actual_close"]
ldf_data = dataobj.get_data(ldt_timestamps, ls_symbols, ls_keys)
d_data = dict(zip(ls_keys, ldf_data))
for s_key in ls_keys:
d_data[s_key] = d_data[s_key].fillna(method="ffill")
d_data[s_key] = d_data[s_key].fillna(method="bfill")
d_data[s_key] = d_data[s_key].fillna(1.0)
df_events = find_events(ls_symbols, d_data, key, limit, days, output, times)
print "Creating Study"
ep.eventprofiler(
df_events,
d_data,
i_lookback=20,
i_lookforward=20,
s_filename=filename,
b_market_neutral=True,
b_errorbars=True,
s_market_sym="SPY",
)
i_no_events = int(np.nansum(df_events.values))
# print 'Test %f' % (i_no_events)
return i_no_events
def main():
print 'Argument List:', str(sys.argv)
startdaysplit = sys.argv[1].split(',')
enddaysplit = sys.argv[2].split(',')
spxversion = sys.argv[3]
nameofchartfile = sys.argv[4]
lookbackPeriod = int(sys.argv[5])
market = 'SPY'
dt_start = dt.datetime(int(startdaysplit[0]),int(startdaysplit[1]), int(startdaysplit[2]), 16, 00, 00)
dt_end = dt.datetime(int(enddaysplit[0]),int(enddaysplit[1]), int(enddaysplit[2]), 16, 00, 00)
# Fetching the NYSE data
closingPrices, ldt_timestamps, ls_symbols, d_data = fetchNYSEDataForEvents(dt_start, dt_end, spxversion, market)
# Converting the two outputs from NYSEDataFetch into one dataframe
df_closingprices = pd.DataFrame(closingPrices, columns = ls_symbols, index = ldt_timestamps)
# Sending the df_closingprices and lookback period to get the bollinger band values, simple moving average of the equities and rolling stddev of the equities
df_bollinger_vals, df_movingavg, df_movingstddev = bo.bollinger(df_closingprices, lookbackPeriod)
# Finding the events
df_events = find_bollinger_events(df_bollinger_vals)
#print "Creating Study"
ep.eventprofiler(df_events, d_data, i_lookback=20, i_lookforward=20, s_filename=nameofchartfile, b_market_neutral=True, b_errorbars=True,s_market_sym='SPY')
def findEvent(fileName, startDate, endDate, limit, output):
dictionary, symbols = fetchData(fileName, startDate, endDate)
closePrice = dictionary['actual_close']
# Creating an empty dataframe
eventData = copy.deepcopy(closePrice)
eventData = eventData * np.NAN
timeStamp = closePrice.index
for symbol in symbols:
for timeID in range(1, len(timeStamp)):
# Calculating the returns for this timestamp
priceToday = closePrice[symbol].ix[timeStamp[timeID - 0]]
priceYest = closePrice[symbol].ix[timeStamp[timeID - 1]]
if (priceYest >= limit) and (priceToday < limit):
eventData[symbol].ix[timeStamp[timeID]] = 1
ep.eventprofiler(eventData,
dictionary,
i_lookback=20,
i_lookforward=20,
s_filename=output,
b_market_neutral=True,
b_errorbars=True,
s_market_sym='SPY')
return eventData
def create_study(ls_symbols, ldt_timestamps, s_study_name, lf_priceDrop):
global dataObj
print "\nGrabbing data to perform {0}".format(s_study_name)
ls_keys = ['close', 'actual_close']
ldf_data = dataObj.get_data(ldt_timestamps, ls_symbols, ls_keys)
print "\nGot data for study {0}".format(s_study_name)
d_data = dict(zip(ls_keys, ldf_data))
for s_key in ls_keys:
d_data[s_key] = d_data[s_key].fillna(method='ffill')
d_data[s_key] = d_data[s_key].fillna(method='bfill')
d_data[s_key] = d_data[s_key].fillna(1.0)
for f_priceDrop in lf_priceDrop:
df_events = find_events(ls_symbols, d_data, f_priceDrop)
new_study_name = s_study_name + str(f_priceDrop).replace(".",
"_") + ".pdf"
print "Creating Study {0}".format(new_study_name)
ep.eventprofiler(df_events,
d_data,
i_lookback=20,
i_lookforward=20,
s_filename=new_study_name,
b_market_neutral=True,
b_errorbars=True,
s_market_sym='SPY')
def profile_events(symbols, events, dt_start, dt_end, filename='MyEventStudy.pdf'):
date_range = du.getNYSEdays(dt_start, dt_end, datetime.timedelta(hours=16))
close_prices = get_close_prices(symbols, date_range, da.DataItem.CLOSE)
close_prices.drop('Date', axis=1, inplace=True)
ep.eventprofiler(events, {'close' : close_prices}, i_lookback=20, i_lookforward=20,
s_filename=filename, b_market_neutral=True, b_errorbars=True,
s_market_sym='SPY')
def event_profiler(ldt_timestamps, symbols_list, price):
dataobj = da.DataAccess('Yahoo')
ls_symbols = dataobj.get_symbols_from_list(symbols_list)
ls_symbols.append('SPY')
ls_keys = ['close', 'actual_close']
ldf_data = dataobj.get_data(ldt_timestamps, ls_symbols, ls_keys)
d_data = dict(zip(ls_keys, ldf_data))
for s_key in ls_keys:
d_data[s_key] = d_data[s_key].fillna(method='ffill')
d_data[s_key] = d_data[s_key].fillna(method='bfill')
d_data[s_key] = d_data[s_key].fillna(1.0)
df_events = find_events(ls_symbols, d_data, price)
print "Creating Study"
ep.eventprofiler(df_events,
d_data,
i_lookback=20,
i_lookforward=20,
s_filename='EventStudy_' + symbols_list + '_' +
str(price) + '.pdf',
b_market_neutral=True,
b_errorbars=True,
s_market_sym='SPY')
def run(dt_start, dt_end, s_list, find_function, filename):
print "-----------------------------------------------------------"
print "Start date: " + str(dt_start)
print "End date : " + str(dt_end)
print "Symbols : " + s_list
print "Filename : " + filename
print "Function : " + find_function.__doc__
ldt_timestamps = du.getNYSEdays(dt_start, dt_end, dt.timedelta(hours=16))
dataobj = da.DataAccess('Yahoo')
ls_symbols = dataobj.get_symbols_from_list(s_list)
ls_symbols.append('SPY')
ls_keys = ['open', 'high', 'low', 'close', 'volume', 'actual_close']
ldf_data = dataobj.get_data(ldt_timestamps, ls_symbols, ls_keys)
d_data = dict(zip(ls_keys, ldf_data))
for s_key in ls_keys:
d_data[s_key] = d_data[s_key].fillna(method='ffill')
d_data[s_key] = d_data[s_key].fillna(method='bfill')
d_data[s_key] = d_data[s_key].fillna(1.0)
event_count, df_events = find_function(ls_symbols, d_data)
print "Events : " + str(event_count)
s_filename = filename
ep.eventprofiler(df_events,
d_data,
i_lookback=20,
i_lookforward=20,
s_filename=s_filename,
b_market_neutral=True,
b_errorbars=True,
s_market_sym='SPY')
print "-----------------------------------------------------------"
def event_study(df_price, bb_ratio, orders, study=None):
bb_ratio_market = bb_ratio['SPY']
print("Finding Events")
df_events = copy.deepcopy(bb_ratio)
df_events = df_events * np.NAN
ldt_timestamps = bb_ratio.index
ls_symbols = bb_ratio.columns
for s_sym in ls_symbols:
for i in range(1, len(ldt_timestamps)):
ts = ldt_timestamps[i]
yes_ts = ldt_timestamps[i - 1]
if (bb_ratio[s_sym].ix[yes_ts] >= -2.0 and
bb_ratio[s_sym].ix[ts] <= -2.0 and
bb_ratio_market.ix[ts] >= 1.0):
df_events[s_sym].ix[ts] = 1
buy_ts = ts
sell_idx = i + 5
if sell_idx >= len(ldt_timestamps):
sell_ts = ldt_timestamps[-1]
else:
sell_ts = ldt_timestamps[sell_idx]
orders.append((buy_ts, s_sym, 'Buy', 100))
orders.append((sell_ts, s_sym, 'Sell', 100))
if study:
print('Creating Study')
ep.eventprofiler(df_events, {'close': df_price}, i_lookback=20, i_lookforward=20, s_filename='%s.pdf' % (
study), b_market_neutral=True, b_errorbars=True, s_market_sym='SPY')
return df_events
def event_study(self, dt_start, dt_end, symbols_list, event_price):
ldt_timestamps = du.getNYSEdays(dt_start, dt_end,
dt.timedelta(hours=16))
print "Data Access"
dataobj = da.DataAccess('Yahoo')
ls_symbols = dataobj.get_symbols_from_list(symbols_list)
ls_symbols.append('SPY')
ls_keys = ['open', 'high', 'low', 'close', 'volume', 'actual_close']
print "Looking Up data"
ldf_data = dataobj.get_data(ldt_timestamps, ls_symbols, ls_keys)
print "dict Data"
d_data = dict(zip(ls_keys, ldf_data))
print "Backfilling NAN data"
for s_key in ls_keys:
d_data[s_key] = d_data[s_key].fillna(method='ffill')
d_data[s_key] = d_data[s_key].fillna(method='bfill')
d_data[s_key] = d_data[s_key].fillna(1.0)
df_events = self.find_events(ls_symbols, d_data, event_price)
print "Creating Study"
date_str = str(dt_start.month) + "-" + str(dt_start.year) + "_" + str(
dt_end.month) + "-" + str(dt_end.year)
filename = "EventStudy-" + date_str + "Price- " + str(
event_price) + ".pdf"
ep.eventprofiler(df_events,
d_data,
i_lookback=20,
i_lookforward=20,
s_filename=filename,
b_market_neutral=True,
b_errorbars=True,
s_market_sym='SPY')
def main(argv):
start_date = dt.datetime.strptime(argv[0], "%Y-%m-%d")
end_date = dt.datetime.strptime(argv[1], "%Y-%m-%d")
symbol_list = argv[2] #sp5002012
output_dir = argv[3]
timestamps = du.getNYSEdays(start_date, end_date, dt.timedelta(hours = 16))
dataobj = da.DataAccess('Yahoo')
symbols = dataobj.get_symbols_from_list(symbol_list)
symbols.append('SPY')
keys = ['close', 'actual_close']
data_dict = dict(zip(keys, dataobj.get_data(timestamps, symbols, keys)))
for key in keys:
data_dict[key] = data_dict[key].fillna(method = 'ffill')
data_dict[key] = data_dict[key].fillna(method = 'bfill')
data_dict[key] = data_dict[key].fillna(1.0)
bollinger = bollinger_bands(symbols, data_dict['close'], timestamps)
events = find_events(symbols, bollinger, timestamps)
ep.eventprofiler(
events,
data_dict,
i_lookback = 20,
i_lookforward = 20,
s_filename = file_name(output_dir, symbol_list, start_date, end_date),
b_market_neutral = True,
b_errorbars = True,
s_market_sym = 'SPY'
)
def processEvent(year, ls_keys, ldf_data, ls_symbols):
start = ti.time()
d_data = dict(zip(ls_keys, ldf_data))
for s_key in ls_keys:
d_data[s_key] = d_data[s_key].fillna(method='ffill')
d_data[s_key] = d_data[s_key].fillna(method='bfill')
d_data[s_key] = d_data[s_key].fillna(1.0)
(df_events, df_events8) = find_events(ls_symbols, d_data)
t3 = ti.time()
print 'Found Events in %f' % (t3 - start)
filename5 = "6dollarprice_" + year + ".pdf"
filename8 = "8dollarprice_" + year + ".pdf"
ep.eventprofiler(df_events,
d_data,
i_lookback=20,
i_lookforward=20,
s_filename=filename5,
b_market_neutral=True,
b_errorbars=True,
s_market_sym='SPY')
#ep.eventprofiler(df_events8, d_data, i_lookback=20, i_lookforward=20,
# s_filename=filename8, b_market_neutral=True, b_errorbars=True, s_market_sym='SPY')
t4 = ti.time()
print 'Study Created in %f' % (t4 - t3)
def create_study(ls_symbols, ldt_timestamps, s_event):
global dataObj, f
print "Grabbing data to perform {0}".format(s_event)
ls_keys = ['close']
ldf_data = dataObj.get_data(ldt_timestamps, ls_symbols, ls_keys)
print "Got data for study {0}".format(s_event)
d_data = dict(zip(ls_keys, ldf_data))
for s_key in ls_keys:
d_data[s_key] = d_data[s_key].fillna(method='ffill')
d_data[s_key] = d_data[s_key].fillna(method='bfill')
d_data[s_key] = d_data[s_key].fillna(1.0)
if s_event == 'bbands':
df_events = find_bband_events(ls_symbols, d_data)
s_study_name = '2012Study-BBand.pdf'
else:
df_events = find_macd_events(ls_symbols, d_data)
s_study_name = '2012Study-MACD.pdf'
if f is not None:
f.close()
print "Creating Study"
ep.eventprofiler(df_events, d_data, i_lookback=20, i_lookforward=20,
s_filename=s_study_name, b_market_neutral=True, b_errorbars=True,
s_market_sym='SPY')
def test_equity_3_down_market_2_up_aapl(self):
dt_start = dt.datetime(2008, 1, 1)
dt_end = dt.datetime(2009, 12, 31)
df_events, d_data = strategy_maker.find_events(dt_start, dt_end, 'SPY', ['AAPL'], evt)
ep.eventprofiler(df_events, d_data, i_lookback=20, i_lookforward=20,
s_filename='test_equity_3_down_market_2_up_aapl_fast.pdf', b_market_neutral=True, b_errorbars=True,
s_market_sym='SPY')
def event_profiler(ldt_timestamps, symbols_list):
dataobj = da.DataAccess('Yahoo')
ls_symbols = dataobj.get_symbols_from_list(symbols_list)
ls_symbols.append('SPY')
ls_keys = ['close', 'actual_close']
ldf_data = dataobj.get_data(ldt_timestamps, ls_symbols, ls_keys)
d_data = dict(zip(ls_keys, ldf_data))
# remove NaN prices
for s_key in ls_keys:
d_data[s_key] = d_data[s_key].fillna(method='ffill')
d_data[s_key] = d_data[s_key].fillna(method='bfill')
d_data[s_key] = d_data[s_key].fillna(1.0)
df_events = find_events(ls_symbols, d_data)
report_filename = "homework2_event_study3_" + symbols_list + ".pdf"
print "Creating Study " + symbols_list
ep.eventprofiler(df_events,
d_data,
i_lookback=20,
i_lookforward=20,
s_filename=report_filename,
b_market_neutral=True,
b_errorbars=True,
s_market_sym='SPY')
def generate_event_profiler(dt_start, dt_end, list_name, event_id):
ldt_timestamps = du.getNYSEdays(dt_start, dt_end, dt.timedelta(hours=16))
data_obj = da.DataAccess('Yahoo')
ls_symbols = data_obj.get_symbols_from_list(list_name)
ls_symbols.append('SPY')
ls_keys = ['open', 'high', 'low', 'close', 'volume', 'actual_close']
ldf_data = data_obj.get_data(ldt_timestamps, ls_symbols, ls_keys)
d_data = dict(zip(ls_keys, ldf_data))
for s_key in ls_keys:
d_data[s_key] = d_data[s_key].fillna(method='ffill')
d_data[s_key] = d_data[s_key].fillna(method='bfill')
d_data[s_key] = d_data[s_key].fillna(1.0)
df_events = find_events(ls_symbols, d_data)
event_file_name = event_id + ".pdf"
print "Creating Study for:", event_id
ep.eventprofiler(df_events,
d_data,
i_lookback=20,
i_lookforward=20,
s_filename=event_file_name,
b_market_neutral=True,
b_errorbars=True,
s_market_sym='SPY')
def main():
"""main function"""
# Construct the two symbol lists SP 500 of 2008 and 2012
dataobj = da.DataAccess('Yahoo')
symbols12 = dataobj.get_symbols_from_list("sp5002012")
symbols12.append('SPY')
lookbackdates = 20
basic_portfolio = BasicPortfolio(symbols12, dt.datetime(2008, 1, 1), dt.datetime(2009, 12, 31))
print 'Start Looking for the events'
df_events = BollingerEventTest(basic_portfolio, lookbackdates)
print 'Start retrieving data from local Yahoo'
d_data = load_local_data_from_yahoo(basic_portfolio.start_date,
basic_portfolio.end_date,
basic_portfolio.tickers)
filename = "BollingerEventStudy12.9.pdf"
ep.eventprofiler(df_events, d_data, i_lookback=20, i_lookforward=20,
s_filename = filename, b_market_neutral=True,
b_errorbars = True, s_market_sym='SPY')
print 'Generate orders with the events'
df_event_trading = GenerateTradingWithEvents(df_events)
df_event_trading.to_csv("ordersbollinger5d.csv", index = False, header = False)
def main():
dt_start = dt.datetime(2008, 1, 1)
dt_end = dt.datetime(2009, 12, 31)
# We need closing prices so the timestamp should be hours=16.
dt_timeofday = dt.timedelta(hours=16)
# Get a list of trading days between the start and the end.
ldt_timestamps = du.getNYSEdays(dt_start, dt_end, dt_timeofday)
print "Getting price data... "
ls_symbols, d_data, d_close,trading_days = loadData(ldt_timestamps)
print "Getting bollinger data... "
bollinger = find_bollinger(d_close, ls_symbols, ldt_timestamps)
print bollinger
print "Finding bollinger events... "
df_events,cnt = find_events(ls_symbols, bollinger)
print "Num. of events: "
print cnt
print "Creating Study"
ep.eventprofiler(df_events, d_data, i_lookback=20, i_lookforward=20,
s_filename='MyEventStudy.pdf', b_market_neutral=True, b_errorbars=True,
s_market_sym='SPY')
def event_study(self, dt_start, dt_end, symbols_list, event_price):
ldt_timestamps = du.getNYSEdays(dt_start, dt_end, dt.timedelta(hours=16))
print "Data Access"
dataobj = da.DataAccess('Yahoo')
ls_symbols = dataobj.get_symbols_from_list(symbols_list)
ls_symbols.append('SPY')
ls_keys = ['open', 'high', 'low', 'close', 'volume', 'actual_close']
print "Looking Up data"
ldf_data = dataobj.get_data(ldt_timestamps, ls_symbols, ls_keys)
print "dict Data"
d_data = dict(zip(ls_keys, ldf_data))
print "Backfilling NAN data"
for s_key in ls_keys:
d_data[s_key] = d_data[s_key].fillna(method = 'ffill')
d_data[s_key] = d_data[s_key].fillna(method = 'bfill')
d_data[s_key] = d_data[s_key].fillna(1.0)
df_events = self.find_events(ls_symbols, d_data, event_price)
print "Creating Study"
date_str= str(dt_start.month) + "-" + str(dt_start.year) + "_" + str(dt_end.month) + "-" + str(dt_end.year)
filename = "EventStudy-" + date_str + "Price- " + str(event_price) + ".pdf"
ep.eventprofiler(df_events, d_data, i_lookback=20, i_lookforward=20,
s_filename=filename, b_market_neutral=True, b_errorbars=True,
s_market_sym='SPY')
def main():
"""main function"""
# Construct the two symbol lists SP 500 of 2008 and 2012
dataobj = da.DataAccess('Yahoo')
symbols12 = dataobj.get_symbols_from_list("sp5002012")
symbols12.append('SPY')
lookbackdates = 20
basic_portfolio = BasicPortfolio(symbols12, dt.datetime(2008, 1, 1),
dt.datetime(2009, 12, 31))
print 'Start Looking for the events'
df_events = BollingerEventTest(basic_portfolio, lookbackdates)
print 'Start retrieving data from local Yahoo'
d_data = load_local_data_from_yahoo(basic_portfolio.start_date,
basic_portfolio.end_date,
basic_portfolio.tickers)
filename = "BollingerEventStudy12.9.pdf"
ep.eventprofiler(df_events,
d_data,
i_lookback=20,
i_lookforward=20,
s_filename=filename,
b_market_neutral=True,
b_errorbars=True,
s_market_sym='SPY')
print 'Generate orders with the events'
df_event_trading = GenerateTradingWithEvents(df_events)
df_event_trading.to_csv("ordersbollinger5d.csv", index=False, header=False)
def main():
'''main function'''
# Construct the two symbol lists SP 500 of 2008 and 2012
dataobj = da.DataAccess('Yahoo')
symbols12 = dataobj.get_symbols_from_list("sp5002012")
symbols12.append('SPY')
# Set the start and end dates of the analysis
startd = dt.datetime(2008, 1, 1 )
endd = dt.datetime(2009, 12, 31)
lookbackdates = 20
print 'Start Looking for the events'
df_events = BollingerEventTest(startd, endd, symbols12, lookbackdates)
print 'Start retrieving data from local Yahoo'
d_data = GetDataLocalYahoo(startd, endd, symbols12)
filename = "BollingerEventStudy12.9.pdf"
ep.eventprofiler(df_events, d_data, i_lookback=20, i_lookforward=20,
s_filename = filename, b_market_neutral=True,
b_errorbars = True, s_market_sym='SPY')
print 'Generate orders with the events'
df_event_trading = GenerateTradingWithEvents(df_events)
df_event_trading.to_csv("ordersbollinger5d.csv", index = False, header = False)
def init(args):
dt_start = dt.datetime.strptime(args.s, dateFmt)
dt_end = dt.datetime.strptime(args.e, dateFmt)
print "Start = ", dt_start, " - ", dt_end
ldt_timestamps = du.getNYSEdays(dt_start, dt_end, dt.timedelta(hours=16))
#ldt_timestampsExt = du.getNYSEdays(dt_start, dt_end+dt.timedelta(days=7), dt.timedelta(hours=16))# append 7 days on to cater for future sell orders
dataobj = da.DataAccess('Yahoo')
ls_symbols = dataobj.get_symbols_from_list(args.sy)
print "How many symbols? ", len(ls_symbols)
#print ls_symbols
ls_symbols.append('SPY')
ls_keys = ['open', 'high', 'low', 'close', 'volume', 'actual_close']
ldf_data = dataobj.get_data(ldt_timestamps, ls_symbols, ls_keys)
d_data = dict(zip(ls_keys, ldf_data))
#Find Events
df_events, ls_orders = find_events(ls_symbols, d_data, stockBigMovement)
#print len(ls_orders)," orders =",ls_orders
print "Saving ", len(ls_orders), " ordersOut.csv"
saveToFile("ordersOut.csv", ls_orders)
print "Creating Study"
ep.eventprofiler(df_events,
d_data,
i_lookback=20,
i_lookforward=20,
s_filename='MyEventStudy.pdf',
b_market_neutral=True,
b_errorbars=True,
s_market_sym='SPY')
def localTest():
ls_symbols = ['AAPL', 'GLD', 'GOOG', 'XOM', 'SPY'] #last one is market
dt_start = dt.datetime(2010, 12, 1)
dt_end = dt.datetime(2011, 12, 31)
lookbackPeriod = 20
dt_feature = dt_start.strftime('%Y%m%d') + '_' + dt_end.strftime('%Y%m%d')
nameofchartfile = 'EventFind' + dt_feature + '.pdf'
closingPrices, ldt_timestamps, d_data = ufl.fetchNYSEData(
dt_start, dt_end, ls_symbols)
df_closingprices = pd.DataFrame(closingPrices,
columns=ls_symbols,
index=ldt_timestamps)
df_bollinger_vals, df_movingavg, df_movingstddev = abc.bollinger(
df_closingprices, lookbackPeriod)
df_events = find_bollinger_events(df_bollinger_vals)
ep.eventprofiler(df_events,
d_data,
i_lookback=20,
i_lookforward=20,
s_filename=nameofchartfile,
b_market_neutral=True,
b_errorbars=True,
s_market_sym='SPY')
def profile_events(dt_start, dt_end, l_events):
dataobj = da.DataAccess('Yahoo')
for e in l_events:
ls_symbols = dataobj.get_symbols_from_list(e.s_list_name)
ls_symbols.append(e.s_bench_sym)
d_data = get_symbol_data(dataobj, ls_symbols, dt_start, dt_end)
df_events, i_event_counter = e.find_events(ls_symbols, d_data)
print "EventProfiler : For the %1.1f %s (%s) event with the components of %s, we find %d events. Date Range = (%s) to (%s)." % (e.f_size, e.s_unit, e.s_feature, e.s_list_name, i_event_counter, dt_start, dt_end)
s_file_name = 'work/%s_event_on_%s' % (e.getName(), e.s_list_name)
ep.eventprofiler(df_events, d_data, i_lookback=20, i_lookforward=20, s_filename=s_file_name + '.pdf', b_market_neutral=True, b_errorbars=True, s_market_sym='SPY')
print "EventProfiler : %s study saved." % (s_file_name)
e.orders_file = s_file_name + '.csv'
writer = csv.writer(open(e.orders_file, 'wb'), delimiter=',')
#row_to_enter = ['Year', 'Month', 'Day', 'Symbol', 'Trade', 'Quantity']
#writer.writerow(row_to_enter)
ldt_timestamps = df_events.index
last_day_index = len(ldt_timestamps)
for i in range(1, last_day_index):
for s_sym in ls_symbols:
if df_events[s_sym].ix[ldt_timestamps[i]] == 1:
dt_buy = ldt_timestamps[i]
row_to_enter = [dt_buy.year, dt_buy.month, dt_buy.day, s_sym, 'Buy', 100]
writer.writerow(row_to_enter)
dt_sell = ldt_timestamps[i+5]
if (i+5) >= last_day_index:
dt_sell = ldt_timestamps[last_day_index]
row_to_enter = [dt_sell.year, dt_sell.month, dt_sell.day, s_sym, 'Sell', 100]
writer.writerow(row_to_enter)
def create_study(ls_symbols, ldt_timestamps, s_event):
global dataObj, f
print "Grabbing data to perform {0}".format(s_event)
ls_keys = ['close']
ldf_data = dataObj.get_data(ldt_timestamps, ls_symbols, ls_keys)
print "Got data for study {0}".format(s_event)
d_data = dict(zip(ls_keys, ldf_data))
for s_key in ls_keys:
d_data[s_key] = d_data[s_key].fillna(method='ffill')
d_data[s_key] = d_data[s_key].fillna(method='bfill')
d_data[s_key] = d_data[s_key].fillna(1.0)
if s_event == 'bbands':
df_events = find_bband_events(ls_symbols, d_data)
s_study_name = '2012Study-BBand.pdf'
else:
df_events = find_macd_events(ls_symbols, d_data)
s_study_name = '2012Study-MACD.pdf'
if f is not None:
f.close()
print "Creating Study"
ep.eventprofiler(df_events,
d_data,
i_lookback=20,
i_lookforward=20,
s_filename=s_study_name,
b_market_neutral=True,
b_errorbars=True,
s_market_sym='SPY')
def question(symbol_list, price_type, price_threshold):
dt_start = dt.datetime(2008, 1, 1)
dt_end = dt.datetime(2009, 12, 31)
ldt_timestamps = du.getNYSEdays(dt_start, dt_end, dt.timedelta(hours=16))
dataobj = da.DataAccess('Yahoo')
ls_symbols = dataobj.get_symbols_from_list(symbol_list)
ls_symbols.append('SPY')
print('Question2: Data Access for %s symbols' % symbol_list)
ls_keys = ['open', 'high', 'low', 'close', 'volume', 'actual_close']
ldf_data = dataobj.get_data(ldt_timestamps, ls_symbols, ls_keys)
d_data = dict(zip(ls_keys, ldf_data))
for s_key in ls_keys:
d_data[s_key] = d_data[s_key].fillna(method='ffill')
d_data[s_key] = d_data[s_key].fillna(method='bfill')
d_data[s_key] = d_data[s_key].fillna(1.0)
df_events = find_events(ls_symbols, d_data, price_type, price_threshold)
print('Creating Study')
ep.eventprofiler(df_events, d_data, i_lookback=20, i_lookforward=20, b_market_neutral=True, b_errorbars=True,
s_filename='Thr_%s_EventProfiler_for_%s.pdf' % (str(price_threshold), symbol_list),
s_market_sym='SPY')
def doit(SPfname, pdfname, barrier) :
dt_start = dt.datetime(2008, 1,1)
dt_end = dt.datetime(2009, 12, 31)
ldt_timestamps = du.getNYSEdays(dt_start, dt_end, dt.timedelta(hours=16))
dataobj = da.DataAccess('Yahoo')
ls_symbols = dataobj.get_symbols_from_list(SPfname)
ls_symbols.append('SPY')
# Obtain market data
ls_keys = ['open', 'high', 'low', 'close', 'volume', 'actual_close']
ldf_data = dataobj.get_data(ldt_timestamps, ls_symbols, ls_keys)
d_data = dict(zip(ls_keys, ldf_data))
# Clean market data
for s_key in ls_keys:
d_data[s_key] = d_data[s_key].fillna(method='ffill')
d_data[s_key] = d_data[s_key].fillna(method='bfill')
d_data[s_key] = d_data[s_key].fillna(1.0)
df_events = find_events(ls_symbols, d_data, barrier)
print "Creating Event Study"
ep.eventprofiler(df_events, d_data, i_lookback=20, i_lookforward=20,
s_filename=pdfname, b_market_neutral=True, b_errorbars=True,
s_market_sym='SPY')
def main():
dt_start = dt.datetime(2008, 1, 1)
dt_end = dt.datetime(2009, 12, 31)
dt_timeofday = dt.timedelta(hours=16)
ldt_timestamps = du.getNYSEdays(dt_start, dt_end, dt_timeofday)
dataobj = da.DataAccess('Yahoo', cachestalltime=0)
ls_symbols = dataobj.get_symbols_from_list("sp5002012")
ls_symbols.append('SPY')
ls_keys = ['open', 'high', 'low', 'close', 'volume', 'actual_close']
ldf_data = dataobj.get_data(ldt_timestamps, ls_symbols, ls_keys)
d_data = dict(zip(ls_keys, ldf_data))
for s_key in ls_keys:
d_data[s_key] = d_data[s_key].fillna(method='ffill')
d_data[s_key] = d_data[s_key].fillna(method='bfill')
d_data[s_key].fillna(1.0)
df_event = find_events(ls_symbols, d_data)
print "Creating Study"
ep.eventprofiler(df_event,
d_data,
i_lookback=20,
i_lookforward=20,
s_filename='MyEventStudy2.pdf',
b_market_neutral=True,
b_errorbars=True,
s_market_sym='SPY')
def profile(self, lmbd_isEvent, s_reportName):
df_events = self.get_events(self.d_data, self.lst_symbols, lmbd_isEvent)
print 'Generating report to ', s_reportName
ep.eventprofiler(df_events, self.d_data, i_lookback=20, i_lookforward=20,
s_filename=s_reportName, b_market_neutral=True, b_errorbars=True,
s_market_sym='SPY')
def buy_on_drop(
symbol_set="sp5002012",
dataobj=dataobj,
start=datetime.datetime(2008, 1, 3),
end=datetime.datetime(2009, 12, 28),
market_sym='$SPX',
threshold=6,
sell_delay=5,
):
'''Compute and display an "event profile" for multiple sets of symbols'''
if symbol_set:
if isinstance(symbol_set, basestring):
if symbol_set.lower().startswith('sp'):
symbol_set = dataobj.get_symbols_from_list(symbol_set.lower())
else:
symbol_set = [
sym.stip().upper() for sym in symbol_set.split(",")
]
else:
symbol_set = dataobj.get_symbols_from_list("sp5002012")
if market_sym:
symbol_set.append(market_sym)
print "Starting Event Study, retrieving data for the {0} symbol list...".format(
symbol_set)
market_data = get_clean_prices(symbol_set,
dataobj=dataobj,
start=start,
end=end)
print "Finding events for {0} symbols between {1} and {2}...".format(
len(symbol_set), start, end)
trigger_kwargs = {'threshold': threshold}
events = find_events(symbol_set,
market_data,
market_sym=market_sym,
trigger=drop_below,
trigger_kwargs=trigger_kwargs)
csvwriter = csv.writer(getattr(args, 'outfile',
open('buy_on_drop_outfile.csv', 'w')),
dialect='excel',
quoting=csv.QUOTE_MINIMAL)
for order in generate_orders(events, sell_delay=sell_delay, sep=None):
csvwriter.writerow(order)
print "Creating Study report for {0} events...".format(len(events))
ep.eventprofiler(
events,
market_data,
i_lookback=20,
i_lookforward=20,
s_filename='Event report--buy on drop below {0} for {1} symbols.pdf'.
format(threshold, len(symbol_set)),
b_market_neutral=True,
b_errorbars=True,
s_market_sym=market_sym,
)
return events
def test_equity_3_down_market_2_up(self):
dt_start = dt.datetime(2008, 1, 1)
dt_end = dt.datetime(2009, 12, 31)
dataobj = da.DataAccess('Yahoo')
ls_symbols = dataobj.get_symbols_from_list('sp5002012')
strategy_maker.find_events(dt_start, dt_end, 'SPY', ls_symbols, evt)
ep.eventprofiler(df_events, d_data, i_lookback=20, i_lookforward=20,
s_filename='test_equity_3_down_market_2_up.pdf', b_market_neutral=True, b_errorbars=True,
s_market_sym='SPY')
def profile_event(event_strategy, ls_symbols, dt_start, dt_end, df_events, i_trade_size, i_duration):
s_file_name = 'work/%s_event_on_%s' % (event_strategy.getName(), event_strategy.s_list_name)
lbd = event_strategy.i_lookback_days
ep.eventprofiler(df_events, event_strategy.d_data, i_lookback=lbd, i_lookforward=lbd,\
s_filename=s_file_name + '.pdf', b_market_neutral=True, b_errorbars=True,\
s_market_sym=event_strategy.s_bench_sym)
print "EventProfiler : %s study saved." % (s_file_name)
generate_trades(event_strategy, ls_symbols, df_events, s_file_name, i_trade_size, i_duration)
def output_study(df_events, df_data, out_file, compare='$SPX', look=20):
# convert to float32 to match expected type for eventprofiler
df_events = (df_events * 1.0).replace(0, np.NaN)
debug("Creating study '%s'" % out_file)
debug("Looking %d days around event and comparing to %s" % (look, compare))
ep.eventprofiler(df_events, df_data, i_lookback=look, i_lookforward=look,
s_filename=out_file, b_market_neutral=True, b_errorbars=True,
s_market_sym=compare)
def create_the_event_profile_from(events, dataDictionary):
print "Profiling the event data"
ep.eventprofiler(events,
dataDictionary,
i_lookback=20,
i_lookforward=20,
s_filename="eventStudy.pdf",
b_market_neutral=True,
b_errorbars=True,
s_market_sym='SPY')
def main():
for sp500tag in ['sp5002008', 'sp5002012']:
d_data = test_data(sp500tag)
for p in [5, 6, 7, 8, 9, 10]:
print('===== price threshold %d. on %s =====' % (p, sp500tag))
df_events = find_events(d_data, p)
output = 'hw2-%s-%d.pdf' % (sp500tag, p)
print('Create Study')
ep.eventprofiler(df_events, d_data, i_lookback=20, i_lookforward=20,
s_filename=output, b_market_neutral=True, b_errorbars=True,
s_market_sym='SPY')
def func1():
dataobj = da.DataAccess('Yahoo')
symbols8 = dataobj.get_symbols_from_list("sp5002008")
symbols8.append('SPY')
symbols12 = dataobj.get_symbols_from_list("sp5002012")
symbols12.append('SPY')
startdate=dt.datetime(2008,1,1)
enddate=dt.datetime(2009, 12,31)
dt_timeofday = dt.timedelta(hours=16)
dt_start = startdate
dt_end = enddate
ls_symbols=symbols12
ldt_timestamps = du.getNYSEdays(startdate, enddate, dt_timeofday)
ls_keys = ['open', 'high', 'low', 'close', 'volume', 'actual_close']
ldf_data = dataobj.get_data(ldt_timestamps, ls_symbols, ls_keys)
d_data = dict(zip(ls_keys, ldf_data))
for s_key in ls_keys:
d_data[s_key] = d_data[s_key].fillna(method = 'ffill')
d_data[s_key] = d_data[s_key].fillna(method = 'bfill')
d_data[s_key] = d_data[s_key].fillna(1.0)
#print ldt_timestamps[1].year
df_close = d_data['actual_close']
df_events = copy.deepcopy(df_close)
df_events = df_events * np.NAN
#norm = na_price / na_price[0,:]
f1=open("orders.csv", "w")
for s_sym in ls_symbols: # for each symbol
#print "Symbol : "+str(s_sym)
for i in range(1, len(ldt_timestamps)): # for each day
df_close[s_sym]
f_symprice_today = df_close[s_sym].ix[ldt_timestamps[i]]
f_symprice_yest = df_close[s_sym].ix[ldt_timestamps[i - 1]]
f_symprice_yest_prev=df_close[s_sym].ix[ldt_timestamps[i - 2]]
if (f_symprice_today-f_symprice_yest >= 5):
df_events[s_sym].ix[ldt_timestamps[i]] = 1
#print "even happened for "+str(s_sym)
today=ldt_timestamps[i]
if(i<len(ldt_timestamps)-5):
fiveday=ldt_timestamps[i+5]
else:
fiveday=ldt_timestamps[len(ldt_timestamps)-1]
print "##"
print >>f1, str(today.year)+","+str(today.month)+","+str(today.day)+","+str(s_sym)+","+"Sell"+","+str(100)
print >> f1, str(fiveday.year)+","+str(fiveday.month)+","+str(fiveday.day)+","+str(s_sym)+","+"Buy"+","+str(100)
print "Creating Study"
ep.eventprofiler(df_events, d_data, i_lookback=20, i_lookforward=20,
s_filename='MyEventStudy.pdf', b_market_neutral=True, b_errorbars=True,
s_market_sym='SPY')
def EventTest(startd, endd, ls_symbols, filename = "MyEventStudy.pdf"):
d_data = GetDataLocalYahoo(startd, endd, ls_symbols)
df_events = find_events(ls_symbols, d_data)
print 'Number of events', np.sum(np.sum(df_events.notnull()))
print "Creating Study"
ep.eventprofiler(df_events, d_data, i_lookback=20, i_lookforward=20,
s_filename = filename, b_market_neutral=True,
b_errorbars = True, s_market_sym='SPY')
def eventStudy(eventName,dt_start,dt_end,getEventFunction,symbols):
ls_portfolio = list()
ls_portfolioLabel = list()
for i in range(5,6,1):
portfolioLabel = eventName + str(i)
eventfilename = portfolioLabel + ".pdf"
ls_portfolioLabel.append(portfolioLabel)
(df_data,df_events) = getEventFunction(dt_start,dt_end,symbols,float(i))
ep.eventprofiler(df_events, df_data, i_lookback=20, i_lookforward=20,s_filename=eventfilename, b_market_neutral=True, b_errorbars=True, s_market_sym='SPY')
df_transactions = generateNPTrades(df_events,df_data,5)
df_port = convertTrans2Portfolio(100000, df_transactions, df_data)
ls_portfolio.append(df_port)
comparePortfolios(dict(zip(ls_portfolioLabel,ls_portfolio)))
def main():
s_date = dt.datetime(2008, 1, 1)
e_date = dt.datetime(2009, 12, 31)
print "Reading data..."
data, symbols = setup(s_date, e_date)
print "Finding events..."
events = create_matrix(data, symbols)
print "Making graph..."
ep.eventprofiler(events,
data,
i_lookback=20,
i_lookforward=20,
s_filename="SP500 2012.pdf")
def buy_on_drop(
args=None,
symbol_set=None,
dataobj=tucker,
start=dt.datetime(2008, 1, 3),
end=dt.datetime(2009, 12, 28),
market_sym='$SPX',
threshold=6,
yr=2012,
sell_delay=5,
):
'''Compute and display an "event profile" for multiple sets of symbols'''
if not symbol_set:
symbol_set = dataobj.get_symbols_from_list("sp500{0}".format(yr))
symbol_set.append(market_sym)
print "Starting Event Study, retrieving data for S&P 500 symbol list for the year {0}...".format(
yr)
market_data = get_clean_data(symbol_set,
dataobj=dataobj,
start=start,
end=end)
print "Finding events for {0} symbols in SP500-{1}...".format(
len(symbol_set), yr)
trigger_kwargs = {'threshold': threshold}
events = find_events(symbol_set,
market_data,
market_sym=market_sym,
trigger=drop_below,
trigger_kwargs=trigger_kwargs)
csvwriter = csv.writer(getattr(args, 'outfile',
open('buy_on_drop_outfile.csv', 'w')),
dialect='excel',
quoting=csv.QUOTE_MINIMAL)
for order in generate_orders(events, sell_delay=sell_delay, sep=None):
csvwriter.writerow(order)
print "Creating Study report for {0} events...".format(len(events))
ep.eventprofiler(
events,
market_data,
i_lookback=20,
i_lookforward=20,
s_filename='Event report--buy on drop below {1} for SP500-{0}.pdf'.
format(yr, threshold),
b_market_neutral=True,
b_errorbars=True,
s_market_sym=market_sym,
)
return events
def main(argv):
print "find_events.py main routine\n"
dt_begin, dt_end, stocks, outfile = get_cmdline_options(argv)
ldt_timestamps, ls_symbols, d_data = read_stock_database(dt_begin, dt_end, stocks)
df_events, events = find_events(ls_symbols, d_data)
write_csvfile(outfile,events)
studyfile = outfile + ".pdf"
print "creating study in file:",studyfile
ep.eventprofiler(df_events, d_data, i_lookback=20, i_lookforward=20,
s_filename=studyfile, b_market_neutral=True, b_errorbars=True,
s_market_sym='SPY')
def q1():
sym2008 = np.loadtxt('C:\Anaconda\Lib\site-packages\QSTK\QSData\Yahoo\Lists\sp5002008.txt',dtype='S10',comments='#')
sym2012 = np.loadtxt('C:\Anaconda\Lib\site-packages\QSTK\QSData\Yahoo\Lists\sp5002012.txt',dtype='S10',comments='#')
# You might get a message about some files being missing, don't worry about it.
#symbols =['BFRE','ATCS','RSERF','GDNEF','LAST','ATTUF','JBFCF','CYVA','SPF','XPO','EHECF','TEMO','AOLS','CSNT','REMI','GLRP','AIFLY','BEE','DJRT','CHSTF','AICAF']
startday = dt.datetime(2008,1,1)
endday = dt.datetime(2009,12,31)
events2008,close2008 = fivebucks(sym2008,startday,endday,verbose=True)
events2012,close2012 = fivebucks(sym2012,startday,endday,verbose=True)
eventprof2008 = ep.eventprofiler(events2008,close2008,20,20,"fivebucks2008stocks.pdf",False,True)
eventprof2012 = ep.eventprofiler(events2012,close2012,20,20,"fivebucks2012stocks.pdf",False,True)
def main():
startTime = dt.datetime(2008, 1, 1)
endTime = dt.datetime(2009, 12, 31)
lookbackPeriod = 20
symbolList = 'SP5002012'
t1, t2, t3 = -2.0, -2.0, 1.2
symbols, marketData = getData(startTime, endTime, symbolList)
bollingerValue = bollingerBand(marketData, lookbackPeriod)
# print(bollingerValue)
events, totalEvent = findEvent(symbols, bollingerValue, lookbackPeriod, t1, t2, t3)
ep.eventprofiler(events, marketData, i_lookback=20, i_lookforward=20,
s_filename=symbolList+'.pdf', b_market_neutral=True, b_errorbars=True,
s_market_sym='SPY')
print(totalEvent)
def testCustomEvent_roseAbove10_2012(self):
print("======================testCustomEvent_roseAbove10_2012===============")
dt_start = dt.datetime(2008,1,1)
dt_end = dt.datetime(2009,12,31)
eventPrice = 10.0
d_data, ls_symbols = self.fetch_data(dt_start, dt_end ,'sp5002012')
df_events = self.find_events_rose_above(ls_symbols, d_data, eventPrice)
print "Creating Study"
ep.eventprofiler(df_events, d_data, i_lookback=20, i_lookforward=20,
s_filename='RoseAbove10Dollars2012EventStudy.pdf', b_market_neutral=True, b_errorbars=True,
s_market_sym='SPY')
pass
def testHwQuestion2(self):
print("======================testHwQuestion2===============")
dt_start = dt.datetime(2008,1,1)
dt_end = dt.datetime(2009,12,31)
eventPrice = 6.0
d_data, ls_symbols = self.fetch_data(dt_start, dt_end ,'sp5002008')
df_events = self.find_events(ls_symbols, d_data, eventPrice)
print "Creating Study"
ep.eventprofiler(df_events, d_data, i_lookback=20, i_lookforward=20,
s_filename='testHwQuestion2EventStudy.pdf', b_market_neutral=True, b_errorbars=True,
s_market_sym='SPY')
pass
def main():
try:
start_date = sys.argv[1].split(',')
end_date = sys.argv[2].split(',')
spx = sys.argv[3]
orders_file = sys.argv[4]
event_amount = np.float32(sys.argv[5])
chart_path = sys.argv[6]
except Exception as e:
print str(e)
print "You need to specify three arguments here:"
print "\tstart date (e.g. 2008,01,01)"
print "\tend date (e.g. 2009,12,31)"
print "\tspx (e.g. sp5002012)"
print "\torders file path (e.g. orders.csv)"
print "\tevent amount as number (e.g. 10)"
print "\tchart file path (e.g. chart.pdf)"
print "Usage:"
print sys.argv[0] + " [start_date] [end_date] [spx] [order_file] [event_amount] [chart_path]"
sys.exit(1)
start_date = dt.datetime(int(start_date[0]),
int(start_date[1]),
int(start_date[2]))
end_date = dt.datetime(int(end_date[0]),
int(end_date[1]),
int(end_date[2]))
timestamps = hp.get_timestamps(start_date, end_date)
data_object = da.DataAccess('Yahoo')
symbols = data_object.get_symbols_from_list(spx)
symbols.append('SPY')
keys = ['open', 'high', 'low', 'close', 'volume', 'actual_close']
raw_data = data_object.get_data(timestamps, symbols, keys)
data = dict(zip(keys, raw_data))
for key in keys:
data[key] = data[key].fillna(method='ffill')
data[key] = data[key].fillna(method='bfill')
data[key] = data[key].fillna(1.0)
events = get_events(symbols, data, event_amount, orders_file)
ep.eventprofiler(events, data, i_lookback=20, i_lookforward=20,
s_filename=chart_path, b_market_neutral=True,
b_errorbars=True, s_market_sym='SPY')
def main(argv):
start = dt.datetime(2008, 1, 1)
end = dt.datetime(2009, 12, 31)
timestamps = du.getNYSEdays(start, end, dt.timedelta(hours = 16))
dataobj = da.DataAccess('Yahoo')
symbols_2008 = dataobj.get_symbols_from_list('sp5002008')
symbols_2008.append('SPY')
symbols_2012 = dataobj.get_symbols_from_list('sp5002012')
symbols_2012.append('SPY')
keys = ['close', 'actual_close']
data_2008 = dataobj.get_data(timestamps, symbols_2008, keys)
data_2012 = dataobj.get_data(timestamps, symbols_2012, keys)
dict_2008 = dict(zip(keys, data_2008))
dict_2012 = dict(zip(keys, data_2012))
for key in keys:
dict_2008[key] = dict_2008[key].fillna(method = 'ffill')
dict_2008[key] = dict_2008[key].fillna(method = 'bfill')
dict_2008[key] = dict_2008[key].fillna(1.0)
dict_2012[key] = dict_2012[key].fillna(method = 'ffill')
dict_2012[key] = dict_2012[key].fillna(method = 'bfill')
dict_2012[key] = dict_2012[key].fillna(1.0)
events_2008 = find_events(symbols_2008, dict_2008, 10.0)
ep.eventprofiler(
events_2008,
dict_2008,
i_lookback = 20,
i_lookforward = 20,
s_filename = './src/homework2/output/event_study_2008.pdf',
b_market_neutral = True,
b_errorbars = True,
s_market_sym = 'SPY'
)
events_2012 = find_events(symbols_2012, dict_2012, 8.0)
ep.eventprofiler(
events_2012,
dict_2012,
i_lookback = 20,
i_lookforward = 20,
s_filename = './src/homework2/output/event_study_2012.pdf',
b_market_neutral = True,
b_errorbars = True,
s_market_sym = 'SPY'
)
def analyzePeriod(dt_start, dt_end, price_threshold, list):
keys = ['open', 'high', 'low', 'close', 'volume', 'actual_close']
data_source = da.DataAccess('Yahoo')
dt_timestamps = du.getNYSEdays(dt_start, dt_end, dt.timedelta(hours=16))
symbols = data_source.get_symbols_from_list(list)
symbols.append('SPY')
data = cleanUpData(dict(zip(keys, data_source.get_data(dt_timestamps, symbols, keys))), keys)
num_events, event_map = findEvent(symbols, data, price_threshold)
print 'For the '+str(price_threshold)+'$ event with S&P500 in '+list[-4:]+', we find '+str(num_events)+' events.' \
'('+dt_start.strftime("%B %d, %Y")+' to '+dt_end.strftime("%B %d, %Y")+').'
# #Note: quantities in printout don't match with those of pdfs (quizes require pdf numbers)
ep.eventprofiler(event_map, data, i_lookback=20, i_lookforward=20, s_filename='EventStudy'+list[-4:]+'.pdf',
b_market_neutral=True, b_errorbars=True,s_market_sym='SPY')
def main():
# Start and End date of the charts
startdate = dateTime.datetime(2008, 1, 1)
enddate = dateTime.datetime(2009, 12, 31)
todaydate = dateTime.timedelta(hours=16)
timestamps = dateUtil.getNYSEdays(startdate, enddate, todaydate)
print("Startdate:",startdate)
print("Enddate",enddate)
prices, symbols = loadprices(timestamps)
close = prices['close']
bollinger_value = compute_bollingerbands(close, symbols)
df_events = findevents(prices,symbols,timestamps, bollinger_value,"orders.csv")
ep.eventprofiler(df_events, prices, i_lookback=20, i_lookforward=20,
s_filename='MyEventStudy.pdf', b_market_neutral=True, b_errorbars=True,
s_market_sym='SPY')
def main():
dt_start = dt.datetime(2008, 1, 1)
dt_end = dt.datetime(2009, 12, 31)
dt_timeofday = dt.timedelta(hours=16)
ldt_timestamps = du.getNYSEdays(dt_start, dt_end, dt_timeofday)
dataobj = da.DataAccess('Yahoo', cachestalltime=0)
ls_symbols1 = dataobj.get_symbols_from_list(
"sp5002008") # 2008 yr's S&P500
#ls_symbols2 = dataobj.get_symbols_from_list("sp5002012")
ls_symbols1.append('SPY')
#ls_symbols2.append('SPY')
ls_keys = ['open', 'high', 'low', 'close', 'volume', 'actual_close']
ldf_data1 = dataobj.get_data(ldt_timestamps, ls_symbols1, ls_keys)
d_data1 = dict(zip(ls_keys, ldf_data1))
# remove the NAN in matrix
for s_key in ls_keys:
d_data1[s_key] = d_data1[s_key].fillna(method='ffill')
d_data1[s_key] = d_data1[s_key].fillna(method='bfill')
d_data1[s_key].fillna(1.0)
df_events1, num_e1 = find_events(ls_symbols1, d_data1)
#ldf_data2 = dataobj.get_data(ldt_timestamps, ls_symbols2, ls_keys)
#d_data2 = dict(zip(ls_keys, ldf_data2))
#for s_key in ls_keys:
# d_data2[s_key] = d_data2[s_key].fillna(method = 'ffill')
# d_data2[s_key] = d_data2[s_key].fillna(method = 'bfill')
# d_data2[s_key].fillna(1.0)
#df_events2, num_e2 = find_events(ls_symbols2, d_data2)
print num_e1
#print num_e2
# use the eventprofile to analyze the events and get a pdf
print "Creating Study"
ep.eventprofiler(df_events1,
d_data1,
i_lookback=20,
i_lookforward=20,
s_filename='MyEventStudy5.pdf',
b_market_neutral=True,
b_errorbars=True,
s_market_sym='SPY')
def event_profiler(self, source='local', filename='event_profile.pdf'):
"""
Warning. This method is extremely slow. Only call it if necessary.
It will be refactored soon.
@param source: data source
@param filename:
"""
all_stock_data = load_all_stock_data(self.start_date, self.end_date, self.tickers, source)
actual_close_key = 'actual_close'
df_events = self._get_events(all_stock_data[actual_close_key])
print 'Number of events', np.sum(np.sum(df_events.notnull()))
print "Creating Study"
ep.eventprofiler(df_events, all_stock_data, i_lookback=20, i_lookforward=20,
s_filename=filename, b_market_neutral=True,
b_errorbars=True, s_market_sym='SPY')
def bollinger_events(ldt_timestamps, lookback):
dataobj = da.DataAccess('Yahoo')
ls_symbols = dataobj.get_symbols_from_list('sp5002012')
ls_symbols.append('SPY')
ls_keys = ['close', 'actual_close']
ldf_data = dataobj.get_data(ldt_timestamps, ls_symbols, ls_keys)
d_data = dict(zip(ls_keys, ldf_data))
for s_key in ls_keys:
d_data[s_key] = d_data[s_key].fillna(method='ffill')
d_data[s_key] = d_data[s_key].fillna(method='bfill')
d_data[s_key] = d_data[s_key].fillna(1.0)
df_close = d_data['close']
df_mean = pd.rolling_mean(df_close, lookback)
df_std = pd.rolling_std(df_close, lookback)
df_bands = (df_close - df_mean) / df_std
df_events = copy.deepcopy(df_close)
df_events = df_events * np.NAN
# Time stamps for the event range
ldt_timestamps = df_close.index
for s_sym in ls_symbols:
for i in range(1, len(ldt_timestamps)):
# Calculating the returns for this timestamp
f_boll_today = df_bands[s_sym].ix[ldt_timestamps[i]]
f_boll_yest = df_bands[s_sym].ix[ldt_timestamps[i - 1]]
f_spy_today = df_bands['SPY'].ix[ldt_timestamps[i]]
if f_boll_today < -2.00 and f_boll_yest >= -2.00 and f_spy_today >= 1.4:
df_events[s_sym].ix[ldt_timestamps[i]] = 1
report_filename = "hw6_event_boll_sp5002012_Q.pdf"
print "Creating Study sp5002012"
ep.eventprofiler(df_events,
d_data,
i_lookback=20,
i_lookforward=20,
s_filename=report_filename,
b_market_neutral=True,
b_errorbars=True,
s_market_sym='SPY')
def init(args):
dt_start = dt.datetime.strptime(args.s, dateFmt)
dt_end = dt.datetime.strptime(args.e, dateFmt)
print "Start = ", dt_start, " - ", dt_end
ldt_timestamps = du.getNYSEdays(dt_start, dt_end, dt.timedelta(hours=16))
#ldt_timestampsExt = du.getNYSEdays(dt_start, dt_end+dt.timedelta(days=7), dt.timedelta(hours=16))# append 7 days on to cater for future sell orders
dataobj = da.DataAccess('Yahoo')
if (args.sl != None):
ls_symbols = (args.sl).split(",")
else:
ls_symbols = dataobj.get_symbols_from_list(args.sIdx)
ls_symbols.append('SPY')
print "How many symbols? ", len(ls_symbols)
#print ls_symbols
ls_keys = ['open', 'high', 'low', 'close', 'volume', 'actual_close']
ldf_data = dataobj.get_data(
ldt_timestamps, ls_symbols,
ls_keys) # big command to get all data for symbols
d_data = dict(zip(ls_keys, ldf_data))
#boll
d_metrics = boll(
data=d_data, symbols=ls_symbols,
noGraph='y') # dict with symbol as key and DataFrame as data
print "Creating Study"
df_events, ls_orders = find_bollEvents(ls_symbols, d_metrics, d_data)
fn = 'MyBollEventStudy.pdf'
print "Generating eventStudy ", fn
ep.eventprofiler(df_events,
d_data,
i_lookback=20,
i_lookforward=20,
s_filename=fn,
b_market_neutral=True,
b_errorbars=True,
s_market_sym='SPY')
# HW7 extension.. Add orders output file
print "Saving ", len(ls_orders), " ordersOut.csv"
saveToFile("ordersOut.csv", ls_orders)
def eventStudy(eventName, dt_start, dt_end, getEventFunction, symbols):
ls_portfolio = list()
ls_portfolioLabel = list()
for i in range(5, 6, 1):
portfolioLabel = eventName + str(i)
eventfilename = portfolioLabel + ".pdf"
ls_portfolioLabel.append(portfolioLabel)
(df_data, df_events) = getEventFunction(dt_start, dt_end, symbols,
float(i))
ep.eventprofiler(df_events,
df_data,
i_lookback=20,
i_lookforward=20,
s_filename=eventfilename,
b_market_neutral=True,
b_errorbars=True,
s_market_sym='SPY')
df_transactions = generateNPTrades(df_events, df_data, 5)
df_port = convertTrans2Portfolio(100000, df_transactions, df_data)
ls_portfolio.append(df_port)
comparePortfolios(dict(zip(ls_portfolioLabel, ls_portfolio)))
def create_study(ls_symbols, ldt_timestamps, s_study_name):
global dataObj
print "Grabbing data to perform {0}".format(s_study_name)
ls_keys = ['close', 'actual_close']
ldf_data = dataObj.get_data(ldt_timestamps, ls_symbols, ls_keys)
print "Got data for study {0}".format(s_study_name)
d_data = dict(zip(ls_keys, ldf_data))
for s_key in ls_keys:
d_data[s_key] = d_data[s_key].fillna(method='ffill')
d_data[s_key] = d_data[s_key].fillna(method='bfill')
d_data[s_key] = d_data[s_key].fillna(1.0)
df_events = find_events(ls_symbols, d_data)
print "Creating Study"
ep.eventprofiler(df_events, d_data, i_lookback=20, i_lookforward=20,
s_filename=s_study_name, b_market_neutral=True, b_errorbars=True,
s_market_sym='SPY')
