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 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')