def generate_spread_carry_sheet_4date(**kwargs):
report_date = kwargs['report_date']
output_dir = ts.create_strategy_output_dir(strategy_class='spread_carry', report_date=report_date)
if os.path.isfile(output_dir + '/summary.pkl'):
spread_report = pd.read_pickle(output_dir + '/summary.pkl')
return {'spread_report': spread_report,'success': True}
if 'futures_data_dictionary' in kwargs.keys():
futures_data_dictionary = kwargs['futures_data_dictionary']
else:
futures_data_dictionary = {x: gfp.get_futures_price_preloaded(ticker_head=x) for x in max_tr_dte_limits.keys()}
spread_list = [get_spread_carry_4tickerhead(ticker_head=x,report_date=report_date,futures_data_dictionary=futures_data_dictionary) for x in max_tr_dte_limits.keys()]
success_list = [x['success'] for x in spread_list]
carry_signals_list = [x['carry_signals'] for x in spread_list]
spread_report = pd.concat([carry_signals_list[x] for x in range(len(spread_list)) if success_list[x]])
spread_report['carry'] = spread_report['carry'].round(2)
spread_report['reward_risk'] = spread_report['reward_risk'].round(2)
spread_report['upside'] = spread_report['upside'].round(2)
spread_report['downside'] = spread_report['downside'].round(2)
spread_report.rename(columns={'ticker_head': 'tickerHead'}, inplace=True)
spread_report.to_pickle(output_dir + '/summary.pkl')
return {'spread_report': spread_report,'success': True}
def generate_scv_formatted_output(**kwargs):
if 'report_date' in kwargs.keys():
report_date = kwargs['report_date']
else:
report_date = exp.doubledate_shift_bus_days()
output_dir = ts.create_strategy_output_dir(strategy_class='scv',
report_date=report_date)
vcs_output = scv.generate_scv_sheet_4date(date_to=report_date)
scv_frame = vcs_output['scv_frame']
filter_out = of.get_scv_filters(data_frame_input=scv_frame,
filter_list=['long1', 'short1'])
good_scv_frame = filter_out['selected_frame']
writer = pd.ExcelWriter(output_dir + '/' + futil.xls_file_names['scv'] +
'.xlsx',
engine='xlsxwriter')
scv_frame.to_excel(writer, sheet_name='all')
good_scv_frame.to_excel(writer, sheet_name='good')
worksheet_good = writer.sheets['good']
worksheet_all = writer.sheets['all']
worksheet_good.freeze_panes(1, 0)
worksheet_all.freeze_panes(1, 0)
worksheet_good.autofilter(0, 0, len(good_scv_frame.index),
len(good_scv_frame.columns))
worksheet_all.autofilter(0, 0, len(scv_frame.index),
len(scv_frame.columns))
def get_smrs_signal_frame(**kwargs):
if 'settle_date' in kwargs.keys():
settle_date = kwargs['settle_date']
else:
settle_date = exp.doubledate_shift_bus_days()
output_dir = ts.create_strategy_output_dir(strategy_class='smrs',
report_date=settle_date)
if os.path.isfile(output_dir + '/summary.pkl'):
stocks = pd.read_pickle(output_dir + '/summary.pkl')
return {'stocks': stocks, 'success': True}
symbol_list = get_symbols(settle_date=settle_date)
result_list = [
smr.get_stock_mrs_signals(symbol=symbol_list[i],
settle_date=settle_date)
for i in range(len(symbol_list))
]
stocks = pd.DataFrame(result_list)
stocks.to_pickle(output_dir + '/summary.pkl')
return {'stocks': stocks, 'success': True}
def get_ts_results_4date(**kwargs):
date_to = kwargs['date_to']
output_dir = ts.create_strategy_output_dir(strategy_class='ts',
report_date=date_to)
if os.path.isfile(output_dir + '/trades.pkl'):
trades = pd.read_pickle(output_dir + '/trades.pkl')
return trades
tickers_4date = get_tickers_4date(**kwargs)
trade_list = []
for i in range(len(tickers_4date.index)):
trade_data = its.get_technical_scalper_4ticker(
ticker=tickers_4date['ticker'].iloc[i],
date_to=date_to)['trade_data']
if not trade_data.empty:
trade_list.append(trade_data)
if len(trade_list) > 0:
trades = pd.concat(trade_list)
trades.to_pickle(output_dir + '/trades.pkl')
else:
trades = pd.DataFrame()
return trades
def get_arma_sheet_4date(**kwargs):
date_to = kwargs['date_to']
output_dir = ts.create_strategy_output_dir(strategy_class='arma',
report_date=date_to)
if os.path.isfile(output_dir + '/summary.pkl'):
arma_sheet = pd.read_pickle(output_dir + '/summary.pkl')
return {'arma_sheet': arma_sheet, 'success': True}
arma_sheet = get_tickers_4date(**kwargs)
signals_output = [
fds.get_arma_signals(ticker_head=x, date_to=date_to)
for x in arma_sheet['ticker_head']
]
arma_sheet = pd.concat([arma_sheet, pd.DataFrame(signals_output)], axis=1)
arma_sheet = arma_sheet[arma_sheet['success']]
arma_sheet = arma_sheet[[
'ticker', 'ticker_head', 'ticker_class', 'forecast',
'normalized_forecast', 'param1', 'param2', 'normalized_target'
]]
arma_sheet.to_pickle(output_dir + '/summary.pkl')
return {'arma_sheet': arma_sheet, 'success': True}
def generate_scv_formatted_output(**kwargs):
if 'report_date' in kwargs.keys():
report_date = kwargs['report_date']
else:
report_date = exp.doubledate_shift_bus_days()
output_dir = ts.create_strategy_output_dir(strategy_class='scv', report_date=report_date)
vcs_output = scv.generate_scv_sheet_4date(date_to=report_date)
scv_frame = vcs_output['scv_frame']
filter_out = of.get_scv_filters(data_frame_input=scv_frame, filter_list=['long1', 'short1'])
good_scv_frame = filter_out['selected_frame']
writer = pd.ExcelWriter(output_dir + '/' + futil.xls_file_names['scv'] + '.xlsx', engine='xlsxwriter')
scv_frame.to_excel(writer, sheet_name='all')
good_scv_frame.to_excel(writer, sheet_name='good')
worksheet_good = writer.sheets['good']
worksheet_all = writer.sheets['all']
worksheet_good.freeze_panes(1, 0)
worksheet_all.freeze_panes(1, 0)
worksheet_good.autofilter(0, 0, len(good_scv_frame.index),
len(good_scv_frame.columns))
worksheet_all.autofilter(0, 0, len(scv_frame.index),
len(scv_frame.columns))
def get_cot_sheet_4date(**kwargs):
date_to = kwargs['date_to']
output_dir = ts.create_strategy_output_dir(strategy_class='cot',
report_date=date_to)
if os.path.isfile(output_dir + '/summary.pkl'):
cot_sheet = pd.read_pickle(output_dir + '/summary.pkl')
return {'cot_sheet': cot_sheet, 'success': True}
ticker_head_list = [
'LN', 'LC', 'FC', 'C', 'S', 'SM', 'BO', 'W', 'KW', 'SB', 'KC', 'CC',
'CT', 'OJ', 'CL', 'HO', 'RB', 'NG', 'ED', 'ES', 'NQ', 'EC', 'JY', 'AD',
'CD', 'BP', 'TY', 'US', 'FV', 'TU', 'GC', 'SI'
]
signals_output = [
fds.get_cot_strategy_signals(ticker_head=x, date_to=date_to)
for x in ticker_head_list
]
cot_sheet = pd.DataFrame()
cot_sheet['ticker_head'] = [
x['ticker_head'] for x in signals_output if x['success']
]
cot_sheet['cot_index_slow'] = [
x['cot_index_slow'] for x in signals_output if x['success']
]
cot_sheet.to_pickle(output_dir + '/summary.pkl')
return {'cot_sheet': cot_sheet, 'success': True}
def generate_ifs_formatted_output(**kwargs):
if 'report_date' in kwargs.keys():
report_date = kwargs['report_date']
else:
report_date = exp.doubledate_shift_bus_days()
output_dir = ts.create_strategy_output_dir(strategy_class='ifs',
report_date=report_date)
ifs_output = ifs.generate_ifs_sheet_4date(date_to=report_date)
intraday_spreads = ifs_output['intraday_spreads']
intraday_spreads.rename(columns={
'ticker_head1': 'tickerHead1',
'ticker_head2': 'tickerHead2',
'ticker_head3': 'tickerHead3'
},
inplace=True)
writer = pd.ExcelWriter(output_dir + '/' + futil.xls_file_names['ifs'] +
'.xlsx',
engine='xlsxwriter')
intraday_spreads.to_excel(writer, sheet_name='all')
def send_hrsn_report(**kwargs):
daily_dir = dna.get_directory_name(ext='daily')
if 'report_date' in kwargs.keys():
report_date = kwargs['report_date']
else:
report_date = exp.doubledate_shift_bus_days()
ibo_dir = ts.create_strategy_output_dir(strategy_class='os', report_date=report_date)
cov_data_integrity = ''
try:
with open(ibo_dir + '/' + 'covDataIntegrity.txt','r') as text_file:
cov_data_integrity = text_file.read()
except Exception:
pass
try:
expiration_report = ef.get_expiration_report(report_date=report_date, con=kwargs['con'])
expiration_report = expiration_report[expiration_report['tr_days_2roll'] < 5]
if expiration_report.empty:
expiration_text = 'No near expirations.'
else:
expiration_text = 'Check for approaching expirations!'
except Exception:
expiration_text = 'Check expiration report for errors!'
se.send_email_with_attachment(subject='hrsn_' + str(report_date),
email_text='cov_data_integrity: ' + cov_data_integrity + "\r\n" + expiration_text,
attachment_list = [daily_dir + '/' + 'pnl_final_' + str(report_date) + '.xlsx', daily_dir +
'/' + 'followup_' + str(report_date) + '.xlsx'])
def generate_ibo_sheet_4date(**kwargs):
date_to = kwargs['date_to']
output_dir = ts.create_strategy_output_dir(strategy_class='ibo', report_date=date_to)
#if os.path.isfile(output_dir + '/summary.pkl') and os.path.isfile(output_dir + '/cov.pkl'):
# sheet_4date = pd.read_pickle(output_dir + '/summary.pkl')
# cov_output = pckl.load(open(output_dir + '/cov.pkl', 'rb'))
# return {'sheet_4date': sheet_4date, 'cov_output': cov_output, 'success': True}
sheet_4date = get_tickers_4date(**kwargs)
num_tickers = len(sheet_4date.index)
sheet_4date = pd.concat([ifs.get_intraday_trend_signals(ticker=sheet_4date.iloc[x]['ticker'],date_to=date_to)['pnl_frame']
for x in range(num_tickers)])
sheet_4date.to_pickle(output_dir + '/summary.pkl')
cov_output = ifs.get_intraday_outright_covariance(**kwargs)
with open(output_dir + '/cov.pkl', 'wb') as handle:
pckl.dump(cov_output, handle)
return {'sheet_4date': sheet_4date, 'cov_output': cov_output, 'success': True}
def get_cot_sheet_4date(**kwargs):
date_to = kwargs['date_to']
output_dir = ts.create_strategy_output_dir(strategy_class='cot',
report_date=date_to)
if os.path.isfile(output_dir + '/summary.pkl'):
cot_sheet = pd.read_pickle(output_dir + '/summary.pkl')
return {'cot_sheet': cot_sheet, 'success': True}
cot_sheet = get_tickers_4date(**kwargs)
signals_output = [
fds.get_cot_strategy_signals(ticker=x, date_to=date_to)
for x in cot_sheet['ticker']
]
cot_sheet = pd.concat([cot_sheet, pd.DataFrame(signals_output)], axis=1)
cot_sheet = cot_sheet[cot_sheet['success']]
cot_sheet = cot_sheet[[
'ticker', 'ticker_head', 'ticker_class', 'change_5_normalized',
'change_10_normalized', 'change_20_normalized', 'change_40_normalized',
'change_60_normalized', 'comm_net_change_1_normalized',
'comm_net_change_2_normalized', 'comm_net_change_4_normalized',
'spec_net_change_1_normalized', 'spec_net_change_2_normalized',
'spec_net_change_4_normalized', 'volume_5_normalized',
'volume_10_normalized', 'volume_20_normalized', 'comm_z', 'spec_z',
'normalized_pnl_5', 'normalized_pnl_10', 'normalized_pnl_20'
]]
cot_sheet.to_pickle(output_dir + '/summary.pkl')
return {'cot_sheet': cot_sheet, 'success': True}
def generate_futures_butterfly_formatted_output(**kwargs):
if 'report_date' in kwargs.keys():
report_date = kwargs['report_date']
else:
report_date = exp.doubledate_shift_bus_days()
output_dir = ts.create_strategy_output_dir(
strategy_class='futures_butterfly', report_date=report_date)
butterfly_output = fb.generate_futures_butterfly_sheet_4date(
date_to=report_date)
butterflies = butterfly_output['butterflies']
filter_out = ff.get_futures_butterfly_filters(
data_frame_input=butterflies, filter_list=['long7', 'short7'])
good_butterflies = filter_out['selected_frame']
good_butterflies = good_butterflies[
(good_butterflies['second_spread_weight_1'] <= 2.5)
& (good_butterflies['second_spread_weight_1'] >= 0.4)]
butterflies_w_selected_columns = butterflies[[
'ticker1', 'ticker2', 'ticker3', 'tickerHead', 'trDte1', 'trDte2',
'trDte3', 'Q', 'QF', 'z1', 'z2', 'z3', 'z4', 'theo_pnl', 'r1', 'r2',
'bf_price', 'RC', 'seasonality', 'second_spread_weight_1', 'upside',
'downside', 'recent_vol_ratio', 'recent_5day_pnl', 'bf_sell_limit',
'bf_buy_limit'
]]
good_butterflies_w_selected_columns = good_butterflies[[
'ticker1', 'ticker2', 'ticker3', 'tickerHead', 'trDte1', 'trDte2',
'trDte3', 'Q', 'QF', 'z1', 'z2', 'z3', 'z4', 'theo_pnl', 'r1', 'r2',
'bf_price', 'RC', 'seasonality', 'second_spread_weight_1', 'upside',
'downside', 'recent_vol_ratio', 'recent_5day_pnl', 'bf_sell_limit',
'bf_buy_limit'
]]
writer = pd.ExcelWriter(
output_dir + '/' + futil.xls_file_names['futures_butterfly'] + '.xlsx',
engine='xlsxwriter')
butterflies_w_selected_columns.to_excel(writer, sheet_name='all')
good_butterflies_w_selected_columns.to_excel(writer, sheet_name='good')
worksheet_good = writer.sheets['good']
worksheet_all = writer.sheets['all']
worksheet_good.freeze_panes(1, 0)
worksheet_all.freeze_panes(1, 0)
worksheet_good.autofilter(0, 0,
len(good_butterflies_w_selected_columns.index),
len(good_butterflies_w_selected_columns.columns))
worksheet_all.autofilter(0, 0, len(butterflies_w_selected_columns.index),
len(butterflies_w_selected_columns.columns))
writer.save()
def generate_ifs_sheet_4date(**kwargs):
date_to = kwargs['date_to']
output_dir = ts.create_strategy_output_dir(strategy_class='ifs', report_date=date_to)
if os.path.isfile(output_dir + '/summary.pkl'):
intraday_spreads = pd.read_pickle(output_dir + '/summary.pkl')
return {'intraday_spreads': intraday_spreads,'success': True}
if 'volume_filter' not in kwargs.keys():
kwargs['volume_filter'] = 10000 #2000
intraday_spreads = get_spreads_4date(**kwargs)
num_spreads = len(intraday_spreads.index)
signals_output = [ifs.get_intraday_spread_signals(ticker_list=[intraday_spreads.iloc[x]['contract1'],
intraday_spreads.iloc[x]['contract2'],
intraday_spreads.iloc[x]['contract3']],
date_to=date_to) for x in range(num_spreads)]
intraday_spreads['z'] = [x['z'] for x in signals_output]
intraday_spreads['recentTrend'] = [x['recent_trend'] for x in signals_output]
intraday_spreads['mean10'] = [x['intraday_mean10'] for x in signals_output]
intraday_spreads['std10'] = [x['intraday_std10'] for x in signals_output]
intraday_spreads['mean5'] = [x['intraday_mean5'] for x in signals_output]
intraday_spreads['std5'] = [x['intraday_std5'] for x in signals_output]
intraday_spreads['mean2'] = [x['intraday_mean2'] for x in signals_output]
intraday_spreads['std2'] = [x['intraday_std2'] for x in signals_output]
intraday_spreads['mean1'] = [x['intraday_mean1'] for x in signals_output]
intraday_spreads['std1'] = [x['intraday_std1'] for x in signals_output]
intraday_spreads['downside'] = [x['downside'] for x in signals_output]
intraday_spreads['upside'] = [x['upside'] for x in signals_output]
intraday_spreads['settle'] = [x['spread_settle'] for x in signals_output]
intraday_spreads['spread_weight'] = [x['spread_weight'] for x in signals_output]
intraday_spreads['portfolio_weight'] = [x['portfolio_weight'] for x in signals_output]
intraday_spreads['maSpreadLow'] = [x['ma_spread_low'] for x in signals_output]
intraday_spreads['maSpreadHigh'] = [x['ma_spread_high'] for x in signals_output]
intraday_spreads['maSpreadLowL'] = [x['ma_spread_lowL'] for x in signals_output]
intraday_spreads['maSpreadHighL'] = [x['ma_spread_highL'] for x in signals_output]
intraday_spreads['is'] = [x['intraday_sharp'] for x in signals_output]
intraday_spreads['z'] = intraday_spreads['z'].round(2)
intraday_spreads['upside'] = intraday_spreads['upside'].round(3)
intraday_spreads['downside'] = intraday_spreads['downside'].round(3)
intraday_spreads['recentTrend'] = intraday_spreads['recentTrend'].round()
intraday_spreads['ticker'] = intraday_spreads.apply(lambda x: x['contract1']+ '_' +x['contract2'] if x['contract3'] is None else x['contract1']+ '_' +x['contract2'] + '_' + x['contract3'] , axis=1)
intraday_spreads.to_pickle(output_dir + '/summary.pkl')
return {'intraday_spreads': intraday_spreads, 'success': True}
def generate_fm_sheet_4date(**kwargs):
date_to = kwargs['date_to']
output_dir = ts.create_strategy_output_dir(strategy_class='fm',
report_date=date_to)
if os.path.isfile(output_dir + '/summary.pkl'):
futures = pd.read_pickle(output_dir + '/summary.pkl')
return {'futures': futures, 'success': True}
ticker_head_list = list(
set(cmi.cme_futures_tickerhead_list)
| set(cmi.futures_butterfly_strategy_tickerhead_list))
signals_list = [
fds.get_fm_signals(ticker_head=x, date_to=date_to)
for x in ticker_head_list
]
futures = pd.DataFrame()
futures['ticker'] = [x['ticker'] for x in signals_list]
futures['ticker_head'] = ticker_head_list
futures['comm_cot_index_slow'] = [
x['comm_cot_index_slow'] for x in signals_list
]
futures['comm_cot_index_fast'] = [
x['comm_cot_index_fast'] for x in signals_list
]
futures['trend_direction'] = [x['trend_direction'] for x in signals_list]
futures['curve_slope'] = [x['curve_slope'] for x in signals_list]
futures['rsi_3'] = [x['rsi_3'] for x in signals_list]
futures['rsi_7'] = [x['rsi_7'] for x in signals_list]
futures['rsi_14'] = [x['rsi_14'] for x in signals_list]
futures['change1'] = [x['change1'] for x in signals_list]
futures['change1_instant'] = [x['change1_instant'] for x in signals_list]
futures['change5'] = [x['change5'] for x in signals_list]
futures['change10'] = [x['change10'] for x in signals_list]
futures['change20'] = [x['change20'] for x in signals_list]
futures['change1_dollar'] = [x['change1_dollar'] for x in signals_list]
futures['change1_instant_dollar'] = [
x['change1_instant_dollar'] for x in signals_list
]
futures['change5_dollar'] = [x['change5_dollar'] for x in signals_list]
futures['change10_dollar'] = [x['change10_dollar'] for x in signals_list]
futures['change20_dollar'] = [x['change20_dollar'] for x in signals_list]
writer = pd.ExcelWriter(output_dir + '/summary.xlsx', engine='xlsxwriter')
futures.to_excel(writer, sheet_name='all')
futures.to_pickle(output_dir + '/summary.pkl')
return {'futures': futures, 'success': True}
def generate_candlestick_sheet_4date(**kwargs):
date_to = kwargs['date_to']
output_dir = ts.create_strategy_output_dir(strategy_class='candlestick',
report_date=date_to)
if os.path.isfile(output_dir + '/summary.pkl'):
sheet_4date = pd.read_pickle(output_dir + '/summary.pkl')
return {'sheet_4date': sheet_4date, 'success': True}
sheet_4date = get_tickers_4date(**kwargs)
num_tickers = len(sheet_4date.index)
signals_output = [
ifs.get_intraday_trend_signals(ticker=sheet_4date.iloc[x]['ticker'],
date_to=date_to)
for x in range(num_tickers)
]
sheet_4date['contract_noise'] = [
x['contract_noise'] for x in signals_output
]
sheet_4date['daily_noise'] = [x['daily_noise'] for x in signals_output]
sheet_4date['average_volume'] = [
x['average_volume'] for x in signals_output
]
sheet_4date['ewma10_50_spread'] = [
x['ewma10_50_spread'] for x in signals_output
]
sheet_4date['ewma20_100_spread'] = [
x['ewma20_100_spread'] for x in signals_output
]
sheet_4date['intraday_mean5'] = [
x['intraday_mean5'] for x in signals_output
]
sheet_4date['intraday_std5'] = [x['intraday_std5'] for x in signals_output]
sheet_4date['intraday_mean2'] = [
x['intraday_mean2'] for x in signals_output
]
sheet_4date['intraday_std2'] = [x['intraday_std2'] for x in signals_output]
sheet_4date['intraday_mean1'] = [
x['intraday_mean1'] for x in signals_output
]
sheet_4date['intraday_std1'] = [x['intraday_std1'] for x in signals_output]
sheet_4date.to_pickle(output_dir + '/summary.pkl')
cov_output = ifs.get_intraday_outright_covariance(**kwargs)
with open(output_dir + '/cov.pkl', 'wb') as handle:
pckl.dump(cov_output, handle)
return {
'sheet_4date': sheet_4date,
'cov_output': cov_output,
'success': True
}
def generate_ics_sheet_4date(**kwargs):
date_to = kwargs['date_to']
output_dir = ts.create_strategy_output_dir(strategy_class='ics',
report_date=date_to)
if os.path.isfile(output_dir + '/summary.pkl'):
intraday_spreads = pd.read_pickle(output_dir + '/summary.pkl')
return {'intraday_spreads': intraday_spreads, 'success': True}
con = msu.get_my_sql_connection(**kwargs)
intraday_spreads = get_spreads_4date(**kwargs)
num_spreads = len(intraday_spreads.index)
signals_output = [
ics.get_ics_signals(ticker=intraday_spreads['ticker'].iloc[x],
con=con,
date_to=date_to) for x in range(num_spreads)
]
intraday_spreads['downside'] = [x['downside'] for x in signals_output]
intraday_spreads['upside'] = [x['upside'] for x in signals_output]
intraday_spreads['front_tr_dte'] = [
x['front_tr_dte'] for x in signals_output
]
intraday_spreads['intraday_mean5'] = [
x['intraday_mean5'] for x in signals_output
]
intraday_spreads['intraday_mean2'] = [
x['intraday_mean2'] for x in signals_output
]
intraday_spreads['intraday_mean1'] = [
x['intraday_mean1'] for x in signals_output
]
intraday_spreads['intraday_std5'] = [
x['intraday_std5'] for x in signals_output
]
intraday_spreads['intraday_std2'] = [
x['intraday_std2'] for x in signals_output
]
intraday_spreads['intraday_std1'] = [
x['intraday_std1'] for x in signals_output
]
intraday_spreads.to_pickle(output_dir + '/summary.pkl')
if 'con' not in kwargs.keys():
con.close()
return {'intraday_spreads': intraday_spreads, 'success': True}
def main():
app = algo.Algo()
con = msu.get_my_sql_connection()
date_now = cu.get_doubledate()
datetime_now = dt.datetime.now()
report_date = exp.doubledate_shift_bus_days()
ticker_head_list = ['HO', 'LC', 'FC', 'NQ'] # avoid HO on wednesdays for now!!
data_list = [gfp.get_futures_price_preloaded(ticker_head=x, settle_date=report_date) for x in ticker_head_list]
ticker_frame = pd.concat(data_list)
ticker_frame.sort(['ticker_head','volume'], ascending=[True, False], inplace=True)
ticker_frame.drop_duplicates(subset=['ticker_head'], take_last=False, inplace=True)
ticker_list = list(ticker_frame['ticker'])
theme_name_list = set([x + '_long' for x in ticker_list]).union(set([x + '_short' for x in ticker_list]))
alias_portfolio = aup.portfolio(ticker_list=theme_name_list)
latest_trade_entry_datetime = dt.datetime(datetime_now.year, datetime_now.month, datetime_now.day, 12, 0, 0)
latest_livestock_exit_datetime = dt.datetime(datetime_now.year, datetime_now.month, datetime_now.day, 13, 55, 0)
latest_macro_exit_datetime = dt.datetime(datetime_now.year, datetime_now.month, datetime_now.day, 15, 55, 0)
daily_sd_dictionary = {}
for i in range(len(ticker_list)):
daily_data_frame = gfp.get_futures_price_preloaded(ticker=ticker_list[i], settle_date_to=report_date)
daily_data_frame['close_diff'] = daily_data_frame['close_price'].diff()
daily_sd_dictionary[ticker_list[i]] = np.std(daily_data_frame['close_diff'].iloc[-40:])
db_alias = 'itf_' + datetime_now.strftime('%b_%y')
strategy_frame = ts.get_open_strategies(as_of_date=int(datetime_now.strftime('%Y%m%d')), con=con)
if db_alias not in strategy_frame.values:
db_strategy_output = ts.generate_db_strategy_from_alias(alias=db_alias, description_string='strategy_class=itf',con=con)
db_alias = db_strategy_output['alias']
app.ticker_list = ticker_list
app.db_alias = db_alias
app.tick_size_dictionary = {x:cmi.tick_size[cmi.get_contract_specs(x)['ticker_head']] for x in ticker_list}
app.daily_sd_dictionary = daily_sd_dictionary
app.contract_multiplier_dictionary = {x:cmi.contract_multiplier[cmi.get_contract_specs(x)['ticker_head']] for x in ticker_list}
app.ticker_head_dictionary = {x:cmi.get_contract_specs(x)['ticker_head'] for x in ticker_list}
app.latest_trade_entry_datetime = latest_trade_entry_datetime
app.latest_trade_exit_datetime_dictionary = {'HO': latest_macro_exit_datetime, 'LC': latest_livestock_exit_datetime, 'FC': latest_livestock_exit_datetime, 'NQ': latest_macro_exit_datetime}
app.alias_portfolio = alias_portfolio
app.output_dir = ts.create_strategy_output_dir(strategy_class='itf', report_date=report_date)
app.log = lg.get_logger(file_identifier='ib_itf',log_level='INFO')
app.con = con
app.connect(client_id=4)
app.run()
def get_results_4date(**kwargs):
date_to = kwargs['date_to']
output_dir = ts.create_strategy_output_dir(strategy_class='ibo',
report_date=date_to)
wait4_eoc_volume_filter = kwargs['wait4_eoc_volume_filter']
trend_filter_type = kwargs['trend_filter_type']
stop_loss_multiplier = kwargs['stop_loss_multiplier'] # 0.3
distance_multiplier = kwargs['distance_multiplier'] # 0.5
time_section_no = kwargs['time_section_no'] # 1
use_filesQ = kwargs['use_filesQ']
file_name = output_dir + '/summary.pkl'
if use_filesQ and os.path.isfile(file_name):
trades_frame = pd.read_pickle(file_name)
return {'trades_frame': trades_frame, 'success': True}
ticker_head_list = cmi.cme_futures_tickerhead_list
#ticker_head_list = ['CL']
data_list = [
gfp.get_futures_price_preloaded(ticker_head=x, settle_date=date_to)
for x in ticker_head_list
]
ticker_frame = pd.concat(data_list)
ticker_frame = ticker_frame[~((ticker_frame['ticker_head'] == 'ED') &
(ticker_frame['tr_dte'] < 250))]
ticker_frame.sort_values(['ticker_head', 'volume'],
ascending=[True, False],
inplace=True)
ticker_frame.drop_duplicates(subset=['ticker_head'],
keep='first',
inplace=True)
result_list = [
get_results_4ticker(ticker=x,
date_to=date_to,
wait4_eoc_volume_filter=wait4_eoc_volume_filter,
trend_filter_type=trend_filter_type,
stop_loss_multiplier=stop_loss_multiplier,
distance_multiplier=distance_multiplier,
time_section_no=time_section_no)
for x in ticker_frame['ticker']
]
trades_frame = pd.concat([x['trades_frame'] for x in result_list])
if use_filesQ:
trades_frame.to_pickle(file_name)
return {'trades_frame': trades_frame, 'success': True}
def get_results_4date(**kwargs):
date_to = kwargs['date_to']
datetime_to = cu.convert_doubledate_2datetime(date_to)
output_dir = ts.create_strategy_output_dir(
strategy_class='futures_directional', report_date=date_to)
if os.path.isfile(output_dir + '/summary.pkl'):
directionals = pd.read_pickle(output_dir + '/summary.pkl')
corr_matrix = pd.read_pickle(output_dir + '/corr.pkl')
return {
'directionals': directionals,
'corr_matrix': corr_matrix,
'success': True
}
ticker_head_list = list(
set(cmi.cme_futures_tickerhead_list +
cmi.futures_butterfly_strategy_tickerhead_list))
results_output = [
get_results_4tickerhead(ticker_head=x, date_to=date_to)
for x in ticker_head_list
]
rolling_data_list = [x.pop('rolling_data') for x in results_output]
directionals = pd.DataFrame(results_output)
directionals['ticker_head'] = ticker_head_list
directionals['weekday'] = datetime_to.weekday()
directionals.to_pickle(output_dir + '/summary.pkl')
aux_frame_list = []
for i in range(len(ticker_head_list)):
rolling_data = rolling_data_list[i].iloc[-20:]
if not rolling_data.empty:
aux_frame = pd.DataFrame(index=rolling_data['settle_date'])
aux_frame[ticker_head_list[i]] = rolling_data['change_1'].values
aux_frame_list.append(aux_frame)
if len(aux_frame_list) > 1:
combined_frame = pd.concat(aux_frame_list, axis=1, join='inner')
corr_matrix = combined_frame.corr()
else:
corr_matrix = pd.DataFrame()
corr_matrix.to_pickle(output_dir + '/corr.pkl')
return {
'directionals': directionals,
'corr_matrix': corr_matrix,
'success': True
}
def generate_ifs_sheet_4date(**kwargs):
date_to = kwargs['date_to']
output_dir = ts.create_strategy_output_dir(strategy_class='ifs', report_date=date_to)
if os.path.isfile(output_dir + '/summary.pkl'):
intraday_spreads = pd.read_pickle(output_dir + '/summary.pkl')
return {'intraday_spreads': intraday_spreads,'success': True}
if 'volume_filter' not in kwargs.keys():
kwargs['volume_filter'] = 2000
intraday_spreads = get_spreads_4date(**kwargs)
num_spreads = len(intraday_spreads.index)
signals_output = [ifs.get_intraday_spread_signals(ticker_list=[intraday_spreads.iloc[x]['contract1'],
intraday_spreads.iloc[x]['contract2'],
intraday_spreads.iloc[x]['contract3']],
date_to=date_to) for x in range(num_spreads)]
intraday_spreads['z'] = [x['z'] for x in signals_output]
intraday_spreads['recentTrend'] = [x['recent_trend'] for x in signals_output]
intraday_spreads['mean'] = [x['intraday_mean'] for x in signals_output]
intraday_spreads['std'] = [x['intraday_std'] for x in signals_output]
intraday_spreads['mean2'] = [x['intraday_mean2'] for x in signals_output]
intraday_spreads['std2'] = [x['intraday_std2'] for x in signals_output]
intraday_spreads['mean1'] = [x['intraday_mean1'] for x in signals_output]
intraday_spreads['std1'] = [x['intraday_std1'] for x in signals_output]
intraday_spreads['downside'] = [x['downside'] for x in signals_output]
intraday_spreads['upside'] = [x['upside'] for x in signals_output]
intraday_spreads['settle'] = [x['spread_settle'] for x in signals_output]
intraday_spreads['hs'] = [x['historical_sharp'] for x in signals_output]
intraday_spreads['z'] = intraday_spreads['z'].round(2)
intraday_spreads['upside'] = intraday_spreads['upside'].round(3)
intraday_spreads['downside'] = intraday_spreads['downside'].round(3)
intraday_spreads['recentTrend'] = intraday_spreads['recentTrend'].round()
intraday_spreads['spread_description'] = intraday_spreads.apply(lambda x: x['ticker_head1']+ '_' +x['ticker_head2'] if x['ticker_head3'] is None else x['ticker_head1']+ '_' +x['ticker_head2'] + '_' + x['ticker_head3'] , axis=1)
intraday_spreads['ticker'] = intraday_spreads.apply(lambda x: x['contract1']+ '_' +x['contract2'] if x['contract3'] is None else x['contract1']+ '_' +x['contract2'] + '_' + x['contract3'] , axis=1)
intraday_spreads['min_volume'] = intraday_spreads.apply(lambda x: min(x['volume1'],x['volume2']) if x['ticker_head3'] is None else min(x['volume1'],x['volume2'],x['volume3']),axis=1)
intraday_spreads.to_pickle(output_dir + '/summary.pkl')
return {'intraday_spreads': intraday_spreads, 'success': True}
def generate_curve_pca_formatted_output(**kwargs):
if "report_date" in kwargs.keys():
report_date = kwargs["report_date"]
else:
report_date = exp.doubledate_shift_bus_days()
output_dir = ts.create_strategy_output_dir(strategy_class="curve_pca", report_date=report_date)
ticker_head_list = ["CL", "B"]
selected_column_list = [
"ticker1",
"ticker2",
"monthSpread",
"tr_dte_front",
"residuals",
"price",
"yield",
"z",
"z2",
"factor_load1",
"factor_load2",
]
writer = pd.ExcelWriter(output_dir + "/" + futil.xls_file_names["curve_pca"] + ".xlsx", engine="xlsxwriter")
for ticker_head in ticker_head_list:
curve_pca_output = cpc.get_curve_pca_report(ticker_head=ticker_head, date_to=report_date)
if curve_pca_output["success"]:
all_spreads = curve_pca_output["pca_results"]
filter_out = ff.get_curve_pca_filters(data_frame_input=all_spreads, filter_list=["long1", "short1"])
good_spreads = filter_out["selected_frame"]
all_spreads = all_spreads[selected_column_list]
good_spreads = good_spreads[selected_column_list]
all_spreads.to_excel(writer, sheet_name=ticker_head + "-all")
good_spreads.to_excel(writer, sheet_name=ticker_head + "-good")
worksheet_good = writer.sheets[ticker_head + "-good"]
worksheet_all = writer.sheets[ticker_head + "-all"]
worksheet_good.freeze_panes(1, 0)
worksheet_all.freeze_panes(1, 0)
worksheet_good.autofilter(0, 0, len(good_spreads.index), len(selected_column_list))
worksheet_all.autofilter(0, 0, len(all_spreads.index), len(selected_column_list))
def generate_vcs_formatted_output(**kwargs):
if 'report_date' in kwargs.keys():
report_date = kwargs['report_date']
else:
report_date = exp.doubledate_shift_bus_days()
output_dir = ts.create_strategy_output_dir(strategy_class='vcs',
report_date=report_date)
vcs_output = vcs.generate_vcs_sheet_4date(date_to=report_date)
vcs_pairs = vcs_output['vcs_pairs']
filter_out = of.get_vcs_filters(data_frame_input=vcs_pairs,
filter_list=['long2', 'short2'])
good_vcs_pairs = filter_out['selected_frame']
vcs_pairs_w_selected_columns = vcs_pairs[[
'ticker1', 'ticker2', 'tickerHead', 'tickerClass', 'trDte1', 'trDte2',
'Q', 'Q1', 'fwdVolQ', 'downside', 'upside', 'atmVolRatio', 'fwdVol',
'realVolRatio', 'atmRealVolRatio', 'theta'
]]
good_vcs_pairs_w_selected_columns = good_vcs_pairs[[
'ticker1', 'ticker2', 'tickerHead', 'tickerClass', 'trDte1', 'trDte2',
'Q', 'Q1', 'fwdVolQ', 'downside', 'upside', 'atmVolRatio', 'fwdVol',
'realVolRatio', 'atmRealVolRatio', 'theta'
]]
writer = pd.ExcelWriter(output_dir + '/' + futil.xls_file_names['vcs'] +
'.xlsx',
engine='xlsxwriter')
vcs_pairs_w_selected_columns.to_excel(writer, sheet_name='all')
good_vcs_pairs_w_selected_columns.to_excel(writer, sheet_name='good')
worksheet_good = writer.sheets['good']
worksheet_all = writer.sheets['all']
worksheet_good.freeze_panes(1, 0)
worksheet_all.freeze_panes(1, 0)
worksheet_good.autofilter(0, 0,
len(good_vcs_pairs_w_selected_columns.index),
len(good_vcs_pairs_w_selected_columns.columns))
worksheet_all.autofilter(0, 0, len(vcs_pairs_w_selected_columns.index),
len(vcs_pairs_w_selected_columns.columns))
writer.save()
def generate_curve_pca_formatted_output(**kwargs):
if 'report_date' in kwargs.keys():
report_date = kwargs['report_date']
else:
report_date = exp.doubledate_shift_bus_days()
output_dir = ts.create_strategy_output_dir(strategy_class='curve_pca',
report_date=report_date)
ticker_head_list = ['CL', 'B']
selected_column_list = [
'ticker1', 'ticker2', 'monthSpread', 'tr_dte_front', 'residuals',
'price', 'yield', 'z', 'z2', 'factor_load1', 'factor_load2'
]
writer = pd.ExcelWriter(output_dir + '/' +
futil.xls_file_names['curve_pca'] + '.xlsx',
engine='xlsxwriter')
for ticker_head in ticker_head_list:
curve_pca_output = cpc.get_curve_pca_report(ticker_head=ticker_head,
date_to=report_date)
if curve_pca_output['success']:
all_spreads = curve_pca_output['pca_results']
filter_out = ff.get_curve_pca_filters(
data_frame_input=all_spreads, filter_list=['long1', 'short1'])
good_spreads = filter_out['selected_frame']
all_spreads = all_spreads[selected_column_list]
good_spreads = good_spreads[selected_column_list]
all_spreads.to_excel(writer, sheet_name=ticker_head + '-all')
good_spreads.to_excel(writer, sheet_name=ticker_head + '-good')
worksheet_good = writer.sheets[ticker_head + '-good']
worksheet_all = writer.sheets[ticker_head + '-all']
worksheet_good.freeze_panes(1, 0)
worksheet_all.freeze_panes(1, 0)
worksheet_good.autofilter(0, 0, len(good_spreads.index),
len(selected_column_list))
worksheet_all.autofilter(0, 0, len(all_spreads.index),
len(selected_column_list))
writer.save()
def prepare_strategy_daily(**kwargs):
strategy_class = kwargs["strategy_class"]
if "report_date" in kwargs.keys():
report_date = kwargs["report_date"]
else:
report_date = exp.doubledate_shift_bus_days()
output_dir = ts.create_strategy_output_dir(strategy_class=strategy_class, report_date=report_date)
sutil.copyfile(
output_dir + "/" + futil.xls_file_names[strategy_class] + ".xlsx",
daily_dir + "/" + futil.xls_file_names[strategy_class] + "_" + str(report_date) + ".xlsx",
)
def prepare_strategy_daily(**kwargs):
strategy_class = kwargs['strategy_class']
if 'report_date' in kwargs.keys():
report_date = kwargs['report_date']
else:
report_date = exp.doubledate_shift_bus_days()
output_dir = ts.create_strategy_output_dir(strategy_class=strategy_class,
report_date=report_date)
sutil.copyfile(
output_dir + '/' + futil.xls_file_names[strategy_class] + '.xlsx',
daily_dir + '/' + futil.xls_file_names[strategy_class] + '_' +
str(report_date) + '.xlsx')
def get_spt_sheet_4date(**kwargs):
report_date = kwargs['report_date']
output_dir = ts.create_strategy_output_dir(strategy_class='spt', report_date=report_date)
if os.path.isfile(output_dir + '/summary.pkl'):
pairs_frame = pd.read_pickle(output_dir + '/summary.pkl')
return {'pairs_frame': pairs_frame, 'success': True}
sector_frame = sd.create_sector_classification_file()
select_frame = sector_frame[sector_frame['industry'] == 'Semiconductors']
signal_output_list = []
ticker1_list = []
ticker2_list = []
for i in range(len(select_frame.index) - 1):
for j in range(i + 1, len(select_frame.index)):
print(select_frame['ticker'].iloc[i] + ', ' + select_frame['ticker'].iloc[j])
ticker1_list.append(select_frame['ticker'].iloc[i])
ticker2_list.append(select_frame['ticker'].iloc[j])
signal_output_list.append(spt.get_summary(symbol1=select_frame['ticker'].iloc[i],
symbol2=select_frame['ticker'].iloc[j],
report_date=report_date))
pairs_frame = pd.DataFrame()
pairs_frame['ticker1'] = ticker1_list
pairs_frame['ticker2'] = ticker2_list
pairs_frame['price1'] = [x['price1'] for x in signal_output_list]
pairs_frame['price2'] = [x['price2'] for x in signal_output_list]
pairs_frame['zScore'] = [x['zScore'] for x in signal_output_list]
pairs_frame['p1'] = [x['p_value_1'] for x in signal_output_list]
pairs_frame['p2'] = [x['p_value_2'] for x in signal_output_list]
pairs_frame['beta1'] = [x['beta_1'] for x in signal_output_list]
pairs_frame['beta2'] = [x['beta_2'] for x in signal_output_list]
pairs_frame['corr'] = [x['corr'] for x in signal_output_list]
pairs_frame['cagr1'] = [x['cagr1'] for x in signal_output_list]
pairs_frame['cagr2'] = [x['cagr2'] for x in signal_output_list]
pairs_frame['kalpha'] = [x['kalpha'] for x in signal_output_list]
pairs_frame['kbeta'] = [x['kbeta'] for x in signal_output_list]
pairs_frame['meanSpread'] = [x['meanSpread'] for x in signal_output_list]
pairs_frame['stdSpread'] = [x['stdSpread'] for x in signal_output_list]
pairs_frame.to_pickle(output_dir + '/summary.pkl')
return {'pairs_frame': pairs_frame, 'success': True}
def generate_spread_carry_sheet_4date(**kwargs):
report_date = kwargs['report_date']
output_dir = ts.create_strategy_output_dir(strategy_class='spread_carry',
report_date=report_date)
if os.path.isfile(output_dir + '/summary.pkl'):
spread_report = pd.read_pickle(output_dir + '/summary.pkl')
return {'spread_report': spread_report, 'success': True}
if 'futures_data_dictionary' in kwargs.keys():
futures_data_dictionary = kwargs['futures_data_dictionary']
else:
futures_data_dictionary = {
x: gfp.get_futures_price_preloaded(ticker_head=x)
for x in max_tr_dte_limits.keys()
}
spread_list = [
get_spread_carry_4tickerhead(
ticker_head=x,
report_date=report_date,
futures_data_dictionary=futures_data_dictionary)
for x in max_tr_dte_limits.keys()
]
success_list = [x['success'] for x in spread_list]
carry_signals_list = [x['carry_signals'] for x in spread_list]
spread_report = pd.concat([
carry_signals_list[x] for x in range(len(spread_list))
if success_list[x]
])
spread_report['carry'] = spread_report['carry'].round(2)
spread_report['q_carry_average'] = spread_report['q_carry_average'].round()
spread_report['reward_risk'] = spread_report['reward_risk'].round(2)
spread_report['upside'] = spread_report['upside'].round(2)
spread_report['downside'] = spread_report['downside'].round(2)
spread_report.rename(columns={'ticker_head': 'tickerHead'}, inplace=True)
spread_report.to_pickle(output_dir + '/summary.pkl')
return {'spread_report': spread_report, 'success': True}
def generate_spread_carry_formatted_output(**kwargs):
if 'report_date' in kwargs.keys():
report_date = kwargs['report_date']
else:
report_date = exp.doubledate_shift_bus_days()
output_dir = ts.create_strategy_output_dir(strategy_class='spread_carry',
report_date=report_date)
spread_carry_output = sc.generate_spread_carry_sheet_4date(
report_date=report_date)
spread_report = spread_carry_output['spread_report']
writer = pd.ExcelWriter(output_dir + '/' +
futil.get_xls_file_name('spread_carry') + '.xlsx',
engine='xlsxwriter')
spread_report.to_excel(writer, sheet_name='summary')
def generate_outright_summary_sheet_4date(**kwargs):
date_to = kwargs['date_to']
output_dir = ts.create_strategy_output_dir(strategy_class='os',
report_date=date_to)
if os.path.isfile(output_dir +
'/summary.pkl') and os.path.isfile(output_dir +
'/cov.pkl'):
sheet_4date = pd.read_pickle(output_dir + '/summary.pkl')
cov_output = pckl.load(open(output_dir + '/cov.pkl', 'rb'))
return {
'sheet_4date': sheet_4date,
'cov_output': cov_output,
'success': True
}
sheet_4date = get_tickers_4date(**kwargs)
num_tickers = len(sheet_4date.index)
signals_output = [
fds.get_contract_summary_stats(ticker=sheet_4date.iloc[x]['ticker'],
date_to=date_to)
for x in range(num_tickers)
]
sheet_4date['daily_noise'] = [x['daily_noise'] for x in signals_output]
sheet_4date['average_volume'] = [
x['average_volume'] for x in signals_output
]
sheet_4date.to_pickle(output_dir + '/summary.pkl')
cov_output = ifs.get_intraday_outright_covariance(**kwargs)
with open(output_dir + '/cov.pkl', 'wb') as handle:
pckl.dump(cov_output, handle)
return {
'sheet_4date': sheet_4date,
'cov_output': cov_output,
'success': True
}
def generate_ifs_formatted_output(**kwargs):
if "report_date" in kwargs.keys():
report_date = kwargs["report_date"]
else:
report_date = exp.doubledate_shift_bus_days()
output_dir = ts.create_strategy_output_dir(strategy_class="ifs", report_date=report_date)
ifs_output = ifs.generate_ifs_sheet_4date(date_to=report_date)
intraday_spreads = ifs_output["intraday_spreads"]
intraday_spreads.rename(
columns={"ticker_head1": "tickerHead1", "ticker_head2": "tickerHead2", "ticker_head3": "tickerHead3"},
inplace=True,
)
writer = pd.ExcelWriter(output_dir + "/" + futil.xls_file_names["ifs"] + ".xlsx", engine="xlsxwriter")
intraday_spreads.to_excel(writer, sheet_name="all")
def get_result_sheet_4date(**kwargs):
date_to = kwargs['date_to']
output_dir = ts.create_strategy_output_dir(
strategy_class='intraday_futures_experimental', report_date=date_to)
if os.path.isfile(output_dir + '/summary.pkl'):
ticker_frame = pd.read_pickle(output_dir + '/summary.pkl')
return {'ticker_frame': ticker_frame, 'success': True}
if 'boto_client' in kwargs.keys():
boto_client = kwargs['boto_client']
else:
boto_client = qgd.get_boto_client()
ticker_frame = get_tickers_4date(**kwargs)
summary_stats_list = [
ife.get_crossover_duration(ticker=x,
date_to=kwargs['date_to'],
boto_client=boto_client)
for x in ticker_frame['ticker']
]
ticker_frame['mean_duration'] = [
x['mean_duration'] for x in summary_stats_list
]
ticker_frame['duration_25'] = [
x['duration_25'] for x in summary_stats_list
]
ticker_frame['duration_75'] = [
x['duration_75'] for x in summary_stats_list
]
ticker_frame['num_crossovers'] = [
x['num_crossovers'] for x in summary_stats_list
]
ticker_frame.to_pickle(output_dir + '/summary.pkl')
return {'ticker_frame': ticker_frame, 'success': True}
def generate_ocs_formatted_output(**kwargs):
if 'report_date' in kwargs.keys():
report_date = kwargs['report_date']
else:
report_date = exp.doubledate_shift_bus_days()
output_dir = ts.create_strategy_output_dir(strategy_class='ocs',
report_date=report_date)
ocs_output = ocs.generate_overnight_spreads_sheet_4date(
date_to=report_date)
overnight_calendars = ocs_output['overnight_calendars']
overnight_calendars = overnight_calendars[
overnight_calendars['butterflyQ'].notnull()]
writer = pd.ExcelWriter(output_dir + '/' + futil.xls_file_names['ocs'] +
'.xlsx',
engine='xlsxwriter')
overnight_calendars.to_excel(writer, sheet_name='all')
def generate_vcs_formatted_output(**kwargs):
if 'report_date' in kwargs.keys():
report_date = kwargs['report_date']
else:
report_date = exp.doubledate_shift_bus_days()
output_dir = ts.create_strategy_output_dir(strategy_class='vcs', report_date=report_date)
vcs_output = vcs.generate_vcs_sheet_4date(date_to=report_date)
vcs_pairs = vcs_output['vcs_pairs']
filter_out = of.get_vcs_filters(data_frame_input=vcs_pairs, filter_list=['long2', 'short2'])
good_vcs_pairs = filter_out['selected_frame']
vcs_pairs_w_selected_columns = vcs_pairs[['ticker1', 'ticker2', 'tickerHead', 'tickerClass', 'trDte1', 'trDte2', 'Q',
'Q1', 'fwdVolQ', 'downside', 'upside', 'atmVolRatio', 'fwdVol','realVolRatio',
'atmRealVolRatio','theta']]
good_vcs_pairs_w_selected_columns = good_vcs_pairs[['ticker1', 'ticker2', 'tickerHead', 'tickerClass', 'trDte1', 'trDte2', 'Q',
'Q1', 'fwdVolQ', 'downside', 'upside', 'atmVolRatio', 'fwdVol','realVolRatio',
'atmRealVolRatio','theta']]
writer = pd.ExcelWriter(output_dir + '/' + futil.xls_file_names['vcs'] + '.xlsx', engine='xlsxwriter')
vcs_pairs_w_selected_columns.to_excel(writer, sheet_name='all')
good_vcs_pairs_w_selected_columns.to_excel(writer, sheet_name='good')
worksheet_good = writer.sheets['good']
worksheet_all = writer.sheets['all']
worksheet_good.freeze_panes(1, 0)
worksheet_all.freeze_panes(1, 0)
worksheet_good.autofilter(0, 0, len(good_vcs_pairs_w_selected_columns.index),
len(good_vcs_pairs_w_selected_columns.columns))
worksheet_all.autofilter(0, 0, len(vcs_pairs_w_selected_columns.index),
len(vcs_pairs_w_selected_columns.columns))
def generate_ibo_formatted_output(**kwargs):
if 'report_date' in kwargs.keys():
report_date = kwargs['report_date']
else:
report_date = exp.doubledate_shift_bus_days()
output_dir = ts.create_strategy_output_dir(strategy_class='ibo', report_date=report_date)
out_dictionary = ibo.generate_ibo_sheet_4date(date_to=report_date)
cov_matrix = out_dictionary['cov_output']['cov_matrix']
cov_matrix.reset_index(drop=False,inplace=True)
writer = pd.ExcelWriter(output_dir + '/' + 'cov_matrix.xlsx', engine='xlsxwriter')
cov_matrix.to_excel(writer, sheet_name='cov_matrix')
writer.save()
cov_data_integrity = round(out_dictionary['cov_output']['cov_data_integrity'], 2)
with open(output_dir + '/' + 'covDataIntegrity.txt','w') as text_file:
text_file.write(str(cov_data_integrity))
def generate_outright_summary_formatted_output(**kwargs):
if 'report_date' in kwargs.keys():
report_date = kwargs['report_date']
else:
report_date = exp.doubledate_shift_bus_days()
output_dir = ts.create_strategy_output_dir(strategy_class='os',
report_date=report_date)
out_dictionary = out_cs.generate_outright_summary_sheet_4date(
date_to=report_date)
cov_matrix = out_dictionary['cov_output']['cov_matrix']
cov_matrix.reset_index(drop=False, inplace=True)
writer = pd.ExcelWriter(output_dir + '/' + 'cov_matrix.xlsx',
engine='xlsxwriter')
cov_matrix.to_excel(writer, sheet_name='cov_matrix')
writer.save()
cov_data_integrity = round(
out_dictionary['cov_output']['cov_data_integrity'], 2)
with open(output_dir + '/' + 'covDataIntegrity.txt', 'w') as text_file:
text_file.write(str(cov_data_integrity))
sheet_4date = out_dictionary['sheet_4date']
writer = pd.ExcelWriter(output_dir + '/summary.xlsx', engine='xlsxwriter')
sheet_4date.to_excel(writer, sheet_name='all')
worksheet_all = writer.sheets['all']
worksheet_all.freeze_panes(1, 0)
worksheet_all.autofilter(0, 0, len(sheet_4date.index),
len(sheet_4date.columns))
writer.save()
def backtest_continuous_ics_4date(**kwargs):
report_date = kwargs['report_date']
output_dir = ts.create_strategy_output_dir(strategy_class='ics',
report_date=report_date)
if os.path.isfile(output_dir + '/backtest_results_cont.pkl'):
backtest_results = pd.read_pickle(output_dir +
'/backtest_results_cont.pkl')
return backtest_results
sheet_output = ics.generate_ics_sheet_4date(date_to=report_date)
intraday_spreads = sheet_output['intraday_spreads']
backtest_results_list = []
date_list = [
exp.doubledate_shift_bus_days(double_date=report_date, shift_in_days=x)
for x in [-1, -2]
]
for i in range(len(intraday_spreads.index)):
backtest_resul4_4ticker = backtest_continuous_ics(
intraday_spreads=intraday_spreads, date_list=date_list, trade_id=i)
backtest_resul4_4ticker['ticker'] = intraday_spreads['ticker'][i]
backtest_resul4_4ticker['ticker_head'] = intraday_spreads[
'ticker_head'][i]
backtest_results_list.append(backtest_resul4_4ticker)
backtest_results = pd.concat(backtest_results_list)
backtest_results['report_date'] = report_date
backtest_results.to_pickle(output_dir + '/backtest_results_cont.pkl')
return backtest_results
def send_hrsn_report(**kwargs):
daily_dir = dn.get_directory_name(ext="daily")
if "report_date" in kwargs.keys():
report_date = kwargs["report_date"]
else:
report_date = exp.doubledate_shift_bus_days()
ibo_dir = ts.create_strategy_output_dir(strategy_class="ibo", report_date=report_date)
cov_data_integrity = ""
try:
with open(ibo_dir + "/" + "covDataIntegrity.txt", "r") as text_file:
cov_data_integrity = text_file.read()
except Exception:
pass
try:
expiration_report = ef.get_expiration_report(report_date=report_date)
expiration_report = expiration_report[expiration_report["tr_dte"] < 10]
if expiration_report.empty:
expiration_text = "No near expirations."
else:
expiration_text = "Check for approaching expirations!"
except Exception:
expiration_text = "Check expiration report for errors!"
se.send_email_with_attachment(
subject="hrsn_" + str(report_date),
email_text="cov_data_integrity: " + cov_data_integrity + "\r\n" + expiration_text,
attachment_list=[
daily_dir + "/" + "pnl_" + str(report_date) + ".xlsx",
daily_dir + "/" + "followup_" + str(report_date) + ".xlsx",
],
)
def get_results_4date(**kwargs):
date_to = kwargs['date_to']
output_dir = ts.create_strategy_output_dir(strategy_class='itf',
report_date=date_to)
if os.path.isfile(output_dir + '/summary.pkl'):
trades_frame = pd.read_pickle(output_dir + '/summary.pkl')
return {'trades_frame': trades_frame, 'success': True}
ticker_head_list = cmi.cme_futures_tickerhead_list
data_list = [
gfp.get_futures_price_preloaded(ticker_head=x, settle_date=date_to)
for x in ticker_head_list
]
ticker_frame = pd.concat(data_list)
ticker_frame = ticker_frame[~((ticker_frame['ticker_head'] == 'ED') &
(ticker_frame['tr_dte'] < 250))]
ticker_frame.sort_values(['ticker_head', 'volume'],
ascending=[True, False],
inplace=True)
ticker_frame.drop_duplicates(subset=['ticker_head'],
keep='first',
inplace=True)
result_list = [
get_results_4ticker(ticker=x, date_to=date_to)
for x in ticker_frame['ticker']
]
trades_frame = pd.concat([x['trades_frame'] for x in result_list])
trades_frame.to_pickle(output_dir + '/summary.pkl')
return {'trades_frame': trades_frame, 'success': True}
def generate_vcs_sheet_4date_legacy(**kwargs):
kwargs['settle_date'] = kwargs['date_to']
num_cal_days_back = 20*365
output_dir = ts.create_strategy_output_dir(strategy_class='vcs', report_date=kwargs['date_to'])
if os.path.isfile(output_dir + '/summary.pkl'):
vcs_pairs = pd.read_pickle(output_dir + '/summary.pkl')
return {'vcs_pairs': vcs_pairs,'success': True}
vcs_pairs = get_vcs_pairs_4date_legacy(**kwargs)
num_pairs = len(vcs_pairs.index)
atm_vol_ratio_list = [None]*num_pairs
q_list = [None]*num_pairs
q2_list = [None]*num_pairs
q1_list = [None]*num_pairs
q5_list = [None]*num_pairs
fwd_vol_q_list = [None]*num_pairs
fwd_vol_q2_list = [None]*num_pairs
fwd_vol_q1_list = [None]*num_pairs
fwd_vol_q5_list = [None]*num_pairs
atm_real_vol_ratio_list = [None]*num_pairs
q_atm_real_vol_ratio_list = [None]*num_pairs
atm_real_vol_ratio_ratio_list = [None]*num_pairs
q_atm_real_vol_ratio_ratio_list = [None]*num_pairs
tr_dte_diff_percent_list = [None]*num_pairs
downside_list = [None]*num_pairs
upside_list = [None]*num_pairs
theta1_list = [None]*num_pairs
theta2_list = [None]*num_pairs
for i in range(num_pairs):
vcs_output = ops.get_vcs_signals_legacy(ticker_list=[vcs_pairs['ticker1'].iloc[i], vcs_pairs['ticker2'].iloc[i]],
tr_dte_list=[vcs_pairs['trDte1'].iloc[i],vcs_pairs['trDte2'].iloc[i]],
num_cal_days_back=num_cal_days_back,settle_date=kwargs['date_to'])
atm_vol_ratio_list[i] = vcs_output['atm_vol_ratio']
q_list[i] = vcs_output['q']
q2_list[i] = vcs_output['q2']
q1_list[i] = vcs_output['q1']
q5_list[i] = vcs_output['q5']
fwd_vol_q_list[i] = vcs_output['fwd_vol_q']
fwd_vol_q2_list[i] = vcs_output['fwd_vol_q2']
fwd_vol_q1_list[i] = vcs_output['fwd_vol_q1']
fwd_vol_q5_list[i] = vcs_output['fwd_vol_q5']
atm_real_vol_ratio_list[i] = vcs_output['atm_real_vol_ratio']
q_atm_real_vol_ratio_list[i] = vcs_output['q_atm_real_vol_ratio']
atm_real_vol_ratio_ratio_list[i] = vcs_output['atm_real_vol_ratio_ratio']
q_atm_real_vol_ratio_ratio_list[i] = vcs_output['q_atm_real_vol_ratio_ratio']
tr_dte_diff_percent_list[i] = vcs_output['tr_dte_diff_percent']
downside_list[i] = vcs_output['downside']
upside_list[i] = vcs_output['upside']
theta1_list[i] = vcs_output['theta1']
theta2_list[i] = vcs_output['theta2']
vcs_pairs['Q'] = q_list
vcs_pairs['Q2'] = q2_list
vcs_pairs['Q1'] = q1_list
vcs_pairs['Q5'] = q5_list
vcs_pairs['fwdVolQ'] = fwd_vol_q_list
vcs_pairs['fwdVolQ2'] = fwd_vol_q2_list
vcs_pairs['fwdVolQ1'] = fwd_vol_q1_list
vcs_pairs['fwdVolQ5'] = fwd_vol_q5_list
vcs_pairs['atmRealVolRatio'] = atm_real_vol_ratio_list
vcs_pairs['atmRealVolRatioQ'] = q_atm_real_vol_ratio_list
vcs_pairs['atmRealVolRatioRatio'] = atm_real_vol_ratio_ratio_list
vcs_pairs['atmRealVolRatioRatioQ'] = q_atm_real_vol_ratio_ratio_list
vcs_pairs['trDteDiffPercent'] = tr_dte_diff_percent_list
vcs_pairs['downside'] = downside_list
vcs_pairs['upside'] = upside_list
vcs_pairs['theta1'] = theta1_list
vcs_pairs['theta2'] = theta2_list
vcs_pairs.to_pickle(output_dir + '/summary.pkl')
return {'vcs_pairs': vcs_pairs, 'success': True}
def generate_futures_butterfly_formatted_output(**kwargs):
if "report_date" in kwargs.keys():
report_date = kwargs["report_date"]
else:
report_date = exp.doubledate_shift_bus_days()
output_dir = ts.create_strategy_output_dir(strategy_class="futures_butterfly", report_date=report_date)
butterfly_output = fb.generate_futures_butterfly_sheet_4date(date_to=report_date)
butterflies = butterfly_output["butterflies"]
filter_out = ff.get_futures_butterfly_filters(data_frame_input=butterflies, filter_list=["long1", "short1"])
good_butterflies = filter_out["selected_frame"]
butterflies_w_selected_columns = butterflies[
[
"ticker1",
"ticker2",
"ticker3",
"tickerHead",
"trDte1",
"trDte2",
"trDte3",
"Q",
"QF",
"z1",
"z2",
"z3",
"z4",
"theo_pnl",
"r1",
"r2",
"bf_price",
"RC",
"seasonality",
"second_spread_weight_1",
"upside",
"downside",
"recent_vol_ratio",
"recent_5day_pnl",
"bf_sell_limit",
"bf_buy_limit",
]
]
good_butterflies_w_selected_columns = good_butterflies[
[
"ticker1",
"ticker2",
"ticker3",
"tickerHead",
"trDte1",
"trDte2",
"trDte3",
"Q",
"QF",
"z1",
"z2",
"z3",
"z4",
"theo_pnl",
"r1",
"r2",
"bf_price",
"RC",
"seasonality",
"second_spread_weight_1",
"upside",
"downside",
"recent_vol_ratio",
"recent_5day_pnl",
"bf_sell_limit",
"bf_buy_limit",
]
]
writer = pd.ExcelWriter(output_dir + "/" + futil.xls_file_names["futures_butterfly"] + ".xlsx", engine="xlsxwriter")
butterflies_w_selected_columns.to_excel(writer, sheet_name="all")
good_butterflies_w_selected_columns.to_excel(writer, sheet_name="good")
worksheet_good = writer.sheets["good"]
worksheet_all = writer.sheets["all"]
worksheet_good.freeze_panes(1, 0)
worksheet_all.freeze_panes(1, 0)
worksheet_good.autofilter(
0, 0, len(good_butterflies_w_selected_columns.index), len(good_butterflies_w_selected_columns.columns)
)
worksheet_all.autofilter(
0, 0, len(butterflies_w_selected_columns.index), len(butterflies_w_selected_columns.columns)
)
def get_backtest_summary_4_date(**kwargs):
report_date = kwargs["report_date"]
futures_data_dictionary = kwargs["futures_data_dictionary"]
if "use_existing_filesQ" in kwargs.keys():
use_existing_filesQ = kwargs["use_existing_filesQ"]
else:
use_existing_filesQ = True
output_dir = ts.create_strategy_output_dir(strategy_class="futures_butterfly", report_date=report_date)
if os.path.isfile(output_dir + "/backtest_results.pkl") and use_existing_filesQ:
return pd.read_pickle(output_dir + "/backtest_results.pkl")
butt_out = opfb.generate_futures_butterfly_sheet_4date(date_to=report_date)
strategy_sheet = butt_out["butterflies"]
num_trades = len(strategy_sheet.index)
holding_period5 = [np.NAN] * num_trades
holding_period10 = [np.NAN] * num_trades
holding_period15 = [np.NAN] * num_trades
holding_period20 = [np.NAN] * num_trades
holding_period25 = [np.NAN] * num_trades
path_pnl5 = [np.NAN] * num_trades
path_pnl10 = [np.NAN] * num_trades
path_pnl15 = [np.NAN] * num_trades
path_pnl20 = [np.NAN] * num_trades
path_pnl25 = [np.NAN] * num_trades
hold_pnl1long = [np.NAN] * num_trades
hold_pnl2long = [np.NAN] * num_trades
hold_pnl5long = [np.NAN] * num_trades
hold_pnl10long = [np.NAN] * num_trades
hold_pnl20long = [np.NAN] * num_trades
hold_pnl1short = [np.NAN] * num_trades
hold_pnl2short = [np.NAN] * num_trades
hold_pnl5short = [np.NAN] * num_trades
hold_pnl10short = [np.NAN] * num_trades
hold_pnl20short = [np.NAN] * num_trades
path_pnl5_per_contract = [np.NAN] * num_trades
path_pnl10_per_contract = [np.NAN] * num_trades
path_pnl15_per_contract = [np.NAN] * num_trades
path_pnl20_per_contract = [np.NAN] * num_trades
path_pnl25_per_contract = [np.NAN] * num_trades
hold_pnl1long_per_contract = [np.NAN] * num_trades
hold_pnl2long_per_contract = [np.NAN] * num_trades
hold_pnl5long_per_contract = [np.NAN] * num_trades
hold_pnl10long_per_contract = [np.NAN] * num_trades
hold_pnl20long_per_contract = [np.NAN] * num_trades
hold_pnl1short_per_contract = [np.NAN] * num_trades
hold_pnl2short_per_contract = [np.NAN] * num_trades
hold_pnl5short_per_contract = [np.NAN] * num_trades
hold_pnl10short_per_contract = [np.NAN] * num_trades
hold_pnl20short_per_contract = [np.NAN] * num_trades
for i in range(num_trades):
sheet_entry = strategy_sheet.iloc[i]
data_list = []
for j in range(3):
ticker_frame = gfp.get_futures_price_preloaded(
ticker=sheet_entry["ticker" + str(j + 1)],
futures_data_dictionary=futures_data_dictionary,
settle_date_from_exclusive=report_date,
)
ticker_frame.set_index("settle_date", drop=False, inplace=True)
data_list.append(ticker_frame)
merged_data = pd.concat(data_list, axis=1, join="inner")
mid_price = (
merged_data["close_price"].iloc[:, 0] * sheet_entry["weight1"]
+ merged_data["close_price"].iloc[:, 2] * sheet_entry["weight3"]
)
ratio_path = mid_price / (-sheet_entry["weight2"] * merged_data["close_price"].iloc[:, 1])
if len(ratio_path.index) < 6:
continue
if sheet_entry["second_spread_weight_1"] < 0:
continue
quantity_long = round(10000 / abs(sheet_entry["downside"]))
quantity_short = -round(10000 / abs(sheet_entry["upside"]))
contracts_traded_per_unit = 4 * (1 + sheet_entry["second_spread_weight_1"])
if sheet_entry["QF"] > 50:
trigger_direction = "going_down"
quantity = quantity_short
elif sheet_entry["QF"] < 50:
trigger_direction = "going_up"
quantity = quantity_long
else:
quantity = np.NAN
total_contracts_traded_per_unit = abs(quantity) * contracts_traded_per_unit
exit5 = bu.find_exit_point(
time_series=ratio_path,
trigger_value=sheet_entry["ratio_target5"],
trigger_direction=trigger_direction,
max_exit_point=min(20, len(ratio_path.index) - 1),
)
exit10 = bu.find_exit_point(
time_series=ratio_path,
trigger_value=sheet_entry["ratio_target10"],
trigger_direction=trigger_direction,
max_exit_point=min(20, len(ratio_path.index) - 1),
)
exit15 = bu.find_exit_point(
time_series=ratio_path,
trigger_value=sheet_entry["ratio_target15"],
trigger_direction=trigger_direction,
max_exit_point=min(20, len(ratio_path.index) - 1),
)
exit20 = bu.find_exit_point(
time_series=ratio_path,
trigger_value=sheet_entry["ratio_target20"],
trigger_direction=trigger_direction,
max_exit_point=min(20, len(ratio_path.index) - 1),
)
exit25 = bu.find_exit_point(
time_series=ratio_path,
trigger_value=sheet_entry["ratio_target25"],
trigger_direction=trigger_direction,
max_exit_point=min(20, len(ratio_path.index) - 1),
)
holding_period5[i] = exit5
holding_period10[i] = exit10
holding_period15[i] = exit15
holding_period20[i] = exit20
holding_period25[i] = exit25
path_path_list = []
hold_pnl_list = []
for exit_indx in [exit5, exit10, exit15, exit20, exit25]:
exit_indx_robust = min(len(ratio_path.index) - 1, exit_indx)
raw_pnl = (
(merged_data["close_price"].iloc[exit_indx_robust, 0] - merged_data["close_price"].iloc[0, 0])
- (1 + sheet_entry["second_spread_weight_1"])
* (merged_data["close_price"].iloc[exit_indx_robust, 1] - merged_data["close_price"].iloc[0, 1])
+ (sheet_entry["second_spread_weight_1"])
* (merged_data["close_price"].iloc[exit_indx_robust, 2] - merged_data["close_price"].iloc[0, 2])
)
path_path_list.append(raw_pnl * sheet_entry["multiplier"] * quantity)
for hold_indx in [1, 2, 5, 10, 20]:
hold_indx_robust = min(len(ratio_path.index) - 1, hold_indx)
hold_pnl = (
(merged_data["close_price"].iloc[hold_indx_robust, 0] - merged_data["close_price"].iloc[0, 0])
- (1 + sheet_entry["second_spread_weight_1"])
* (merged_data["close_price"].iloc[hold_indx_robust, 1] - merged_data["close_price"].iloc[0, 1])
+ (sheet_entry["second_spread_weight_1"])
* (merged_data["close_price"].iloc[hold_indx_robust, 2] - merged_data["close_price"].iloc[0, 2])
)
hold_pnl_list.append(hold_pnl * sheet_entry["multiplier"])
path_pnl5[i] = path_path_list[0]
path_pnl10[i] = path_path_list[1]
path_pnl15[i] = path_path_list[2]
path_pnl20[i] = path_path_list[3]
path_pnl25[i] = path_path_list[4]
path_pnl5_per_contract[i] = path_path_list[0] / total_contracts_traded_per_unit
path_pnl10_per_contract[i] = path_path_list[1] / total_contracts_traded_per_unit
path_pnl15_per_contract[i] = path_path_list[2] / total_contracts_traded_per_unit
path_pnl20_per_contract[i] = path_path_list[3] / total_contracts_traded_per_unit
path_pnl25_per_contract[i] = path_path_list[4] / total_contracts_traded_per_unit
hold_pnl1long[i] = hold_pnl_list[0] * quantity_long
hold_pnl2long[i] = hold_pnl_list[1] * quantity_long
hold_pnl5long[i] = hold_pnl_list[2] * quantity_long
hold_pnl10long[i] = hold_pnl_list[3] * quantity_long
hold_pnl20long[i] = hold_pnl_list[4] * quantity_long
hold_pnl1long_per_contract[i] = hold_pnl_list[0] / contracts_traded_per_unit
hold_pnl2long_per_contract[i] = hold_pnl_list[1] / contracts_traded_per_unit
hold_pnl5long_per_contract[i] = hold_pnl_list[2] / contracts_traded_per_unit
hold_pnl10long_per_contract[i] = hold_pnl_list[3] / contracts_traded_per_unit
hold_pnl20long_per_contract[i] = hold_pnl_list[4] / contracts_traded_per_unit
hold_pnl1short[i] = hold_pnl_list[0] * quantity_short
hold_pnl2short[i] = hold_pnl_list[1] * quantity_short
hold_pnl5short[i] = hold_pnl_list[2] * quantity_short
hold_pnl10short[i] = hold_pnl_list[3] * quantity_short
hold_pnl20short[i] = hold_pnl_list[4] * quantity_short
hold_pnl1short_per_contract[i] = -hold_pnl_list[0] / contracts_traded_per_unit
hold_pnl2short_per_contract[i] = -hold_pnl_list[1] / contracts_traded_per_unit
hold_pnl5short_per_contract[i] = -hold_pnl_list[2] / contracts_traded_per_unit
hold_pnl10short_per_contract[i] = -hold_pnl_list[3] / contracts_traded_per_unit
hold_pnl20short_per_contract[i] = -hold_pnl_list[4] / contracts_traded_per_unit
strategy_sheet["holding_period5"] = holding_period5
strategy_sheet["holding_period10"] = holding_period10
strategy_sheet["holding_period15"] = holding_period15
strategy_sheet["holding_period20"] = holding_period20
strategy_sheet["holding_period25"] = holding_period25
strategy_sheet["path_pnl5"] = path_pnl5
strategy_sheet["path_pnl10"] = path_pnl10
strategy_sheet["path_pnl15"] = path_pnl15
strategy_sheet["path_pnl20"] = path_pnl20
strategy_sheet["path_pnl25"] = path_pnl25
strategy_sheet["path_pnl5_per_contract"] = path_pnl5_per_contract
strategy_sheet["path_pnl10_per_contract"] = path_pnl10_per_contract
strategy_sheet["path_pnl15_per_contract"] = path_pnl15_per_contract
strategy_sheet["path_pnl20_per_contract"] = path_pnl20_per_contract
strategy_sheet["path_pnl25_per_contract"] = path_pnl25_per_contract
strategy_sheet["hold_pnl1long"] = hold_pnl1long
strategy_sheet["hold_pnl2long"] = hold_pnl2long
strategy_sheet["hold_pnl5long"] = hold_pnl5long
strategy_sheet["hold_pnl10long"] = hold_pnl10long
strategy_sheet["hold_pnl20long"] = hold_pnl20long
strategy_sheet["hold_pnl1long_per_contract"] = hold_pnl1long_per_contract
strategy_sheet["hold_pnl2long_per_contract"] = hold_pnl2long_per_contract
strategy_sheet["hold_pnl5long_per_contract"] = hold_pnl5long_per_contract
strategy_sheet["hold_pnl10long_per_contract"] = hold_pnl10long_per_contract
strategy_sheet["hold_pnl20long_per_contract"] = hold_pnl20long_per_contract
strategy_sheet["hold_pnl1short"] = hold_pnl1short
strategy_sheet["hold_pnl2short"] = hold_pnl2short
strategy_sheet["hold_pnl5short"] = hold_pnl5short
strategy_sheet["hold_pnl10short"] = hold_pnl10short
strategy_sheet["hold_pnl20short"] = hold_pnl20short
strategy_sheet["hold_pnl1short_per_contract"] = hold_pnl1short_per_contract
strategy_sheet["hold_pnl2short_per_contract"] = hold_pnl2short_per_contract
strategy_sheet["hold_pnl5short_per_contract"] = hold_pnl5short_per_contract
strategy_sheet["hold_pnl10short_per_contract"] = hold_pnl10short_per_contract
strategy_sheet["hold_pnl20short_per_contract"] = hold_pnl20short_per_contract
strategy_sheet["report_date"] = report_date
strategy_sheet["hold_pnl1"] = [np.NAN] * num_trades
strategy_sheet["hold_pnl2"] = [np.NAN] * num_trades
strategy_sheet["hold_pnl5"] = [np.NAN] * num_trades
strategy_sheet["hold_pnl10"] = [np.NAN] * num_trades
strategy_sheet["hold_pnl20"] = [np.NAN] * num_trades
strategy_sheet["hold_pnl1_per_contract"] = [np.NAN] * num_trades
strategy_sheet["hold_pnl2_per_contract"] = [np.NAN] * num_trades
strategy_sheet["hold_pnl5_per_contract"] = [np.NAN] * num_trades
strategy_sheet["hold_pnl10_per_contract"] = [np.NAN] * num_trades
strategy_sheet["hold_pnl20_per_contract"] = [np.NAN] * num_trades
strategy_sheet.loc[strategy_sheet["QF"] > 50, "hold_pnl1"] = strategy_sheet.loc[
strategy_sheet["QF"] > 50, "hold_pnl1short"
]
strategy_sheet.loc[strategy_sheet["QF"] > 50, "hold_pnl2"] = strategy_sheet.loc[
strategy_sheet["QF"] > 50, "hold_pnl2short"
]
strategy_sheet.loc[strategy_sheet["QF"] > 50, "hold_pnl5"] = strategy_sheet.loc[
strategy_sheet["QF"] > 50, "hold_pnl5short"
]
strategy_sheet.loc[strategy_sheet["QF"] > 50, "hold_pnl10"] = strategy_sheet.loc[
strategy_sheet["QF"] > 50, "hold_pnl10short"
]
strategy_sheet.loc[strategy_sheet["QF"] > 50, "hold_pnl20"] = strategy_sheet.loc[
strategy_sheet["QF"] > 50, "hold_pnl20short"
]
strategy_sheet.loc[strategy_sheet["QF"] < 50, "hold_pnl1"] = strategy_sheet.loc[
strategy_sheet["QF"] < 50, "hold_pnl1long"
]
strategy_sheet.loc[strategy_sheet["QF"] < 50, "hold_pnl2"] = strategy_sheet.loc[
strategy_sheet["QF"] < 50, "hold_pnl2long"
]
strategy_sheet.loc[strategy_sheet["QF"] < 50, "hold_pnl5"] = strategy_sheet.loc[
strategy_sheet["QF"] < 50, "hold_pnl5long"
]
strategy_sheet.loc[strategy_sheet["QF"] < 50, "hold_pnl10"] = strategy_sheet.loc[
strategy_sheet["QF"] < 50, "hold_pnl10long"
]
strategy_sheet.loc[strategy_sheet["QF"] < 50, "hold_pnl20"] = strategy_sheet.loc[
strategy_sheet["QF"] < 50, "hold_pnl20long"
]
strategy_sheet.loc[strategy_sheet["QF"] > 50, "hold_pnl1_per_contract"] = strategy_sheet.loc[
strategy_sheet["QF"] > 50, "hold_pnl1short_per_contract"
]
strategy_sheet.loc[strategy_sheet["QF"] > 50, "hold_pnl2_per_contract"] = strategy_sheet.loc[
strategy_sheet["QF"] > 50, "hold_pnl2short_per_contract"
]
strategy_sheet.loc[strategy_sheet["QF"] > 50, "hold_pnl5_per_contract"] = strategy_sheet.loc[
strategy_sheet["QF"] > 50, "hold_pnl5short_per_contract"
]
strategy_sheet.loc[strategy_sheet["QF"] > 50, "hold_pnl10_per_contract"] = strategy_sheet.loc[
strategy_sheet["QF"] > 50, "hold_pnl10short_per_contract"
]
strategy_sheet.loc[strategy_sheet["QF"] > 50, "hold_pnl20_per_contract"] = strategy_sheet.loc[
strategy_sheet["QF"] > 50, "hold_pnl20short_per_contract"
]
strategy_sheet.loc[strategy_sheet["QF"] < 50, "hold_pnl1_per_contract"] = strategy_sheet.loc[
strategy_sheet["QF"] < 50, "hold_pnl1long_per_contract"
]
strategy_sheet.loc[strategy_sheet["QF"] < 50, "hold_pnl2_per_contract"] = strategy_sheet.loc[
strategy_sheet["QF"] < 50, "hold_pnl2long_per_contract"
]
strategy_sheet.loc[strategy_sheet["QF"] < 50, "hold_pnl5_per_contract"] = strategy_sheet.loc[
strategy_sheet["QF"] < 50, "hold_pnl5long_per_contract"
]
strategy_sheet.loc[strategy_sheet["QF"] < 50, "hold_pnl10_per_contract"] = strategy_sheet.loc[
strategy_sheet["QF"] < 50, "hold_pnl10long_per_contract"
]
strategy_sheet.loc[strategy_sheet["QF"] < 50, "hold_pnl20_per_contract"] = strategy_sheet.loc[
strategy_sheet["QF"] < 50, "hold_pnl20long_per_contract"
]
strategy_sheet.to_pickle(output_dir + "/backtest_results.pkl")
return strategy_sheet
def generate_scv_sheet_4date(**kwargs):
date_to = kwargs['date_to']
output_dir = ts.create_strategy_output_dir(strategy_class='scv', report_date=date_to)
if os.path.isfile(output_dir + '/summary.pkl'):
scv_frame = pd.read_pickle(output_dir + '/summary.pkl')
return {'scv_frame': scv_frame, 'success': True}
con = msu.get_my_sql_connection(**kwargs)
scv_frame = get_single_contracts_4date(settle_date=date_to, con=con)
futures_data_dictionary = {x: gfp.get_futures_price_preloaded(ticker_head=x) for x in cmi.cme_futures_tickerhead_list}
num_tickers = len(scv_frame.index)
q_list = [None]*num_tickers
downside_list = [None]*num_tickers
upside_list = [None]*num_tickers
theta_list = [None]*num_tickers
realized_vol_forecast_list = [None]*num_tickers
realized_vol20_list = [None]*num_tickers
imp_vol_list = [None]*num_tickers
imp_vol_premium_list = [None]*num_tickers
for i in range(num_tickers):
#print(scv_frame['ticker'].iloc[i])
scv_output = scvs.get_scv_signals(ticker=scv_frame['ticker'].iloc[i], date_to=date_to,
con=con, futures_data_dictionary=futures_data_dictionary)
q_list[i] = scv_output['q']
downside_list[i] = scv_output['downside']
upside_list[i] = scv_output['upside']
theta_list[i] = scv_output['theta']
imp_vol_premium_list[i] = scv_output['imp_vol_premium']
imp_vol_list[i] = scv_output['imp_vol']
realized_vol_forecast_list[i] = scv_output['realized_vol_forecast']
realized_vol20_list[i] = scv_output['real_vol20_current']
scv_frame['Q'] = q_list
scv_frame['premium'] = imp_vol_premium_list
scv_frame['impVol'] = imp_vol_list
scv_frame['forecast'] = realized_vol_forecast_list
scv_frame['realVol20'] = realized_vol20_list
scv_frame['downside'] = downside_list
scv_frame['upside'] = upside_list
scv_frame['theta'] = theta_list
scv_frame['downside'] = scv_frame['downside'].round(2)
scv_frame['upside'] = scv_frame['upside'].round(2)
scv_frame['theta'] = scv_frame['theta'].round(2)
scv_frame['premium'] = scv_frame['premium'].round(1)
scv_frame['forecast'] = scv_frame['forecast'].round(2)
scv_frame['realVol20'] = scv_frame['realVol20'].round(2)
scv_frame['impVol'] = scv_frame['impVol'].round(2)
scv_frame.to_pickle(output_dir + '/summary.pkl')
return {'scv_frame': scv_frame, 'success': True}
def generate_futures_butterfly_sheet_4date(**kwargs):
date_to = kwargs['date_to']
output_dir = ts.create_strategy_output_dir(strategy_class='futures_butterfly', report_date=date_to)
if os.path.isfile(output_dir + '/summary.pkl'):
butterflies = pd.read_pickle(output_dir + '/summary.pkl')
return {'butterflies': butterflies,'success': True}
if 'volume_filter' not in kwargs.keys():
kwargs['volume_filter'] = 100
butterflies = get_futures_butterflies_4date(**kwargs)
butterflies = butterflies[butterflies['trDte1'] >= 35]
butterflies.reset_index(drop=True,inplace=True)
num_butterflies = len(butterflies)
q_list = [None]*num_butterflies
qf_list = [None]*num_butterflies
zscore1_list = [None]*num_butterflies
zscore2_list = [None]*num_butterflies
zscore3_list = [None]*num_butterflies
zscore4_list = [None]*num_butterflies
zscore5_list = [None]*num_butterflies
zscore6_list = [None]*num_butterflies
zscore7_list = [None]*num_butterflies
rsquared1_list = [None]*num_butterflies
rsquared2_list = [None]*num_butterflies
regime_change_list = [None]*num_butterflies
contract_seasonality_list = [None]*num_butterflies
yield1_list = [None]*num_butterflies
yield2_list = [None]*num_butterflies
bf_price_list = [None]*num_butterflies
bf_price_sell_limit_list = [None]*num_butterflies
bf_price_buy_limit_list = [None]*num_butterflies
noise_ratio_list = [None]*num_butterflies
alpha1_list = [None]*num_butterflies
alpha2_list = [None]*num_butterflies
residual_std1_list = [None]*num_butterflies
residual_std2_list = [None]*num_butterflies
second_spread_weight_1_list = [None]*num_butterflies
second_spread_weight_2_list = [None]*num_butterflies
weight1_list = [None]*num_butterflies
weight2_list = [None]*num_butterflies
weight3_list = [None]*num_butterflies
downside_list = [None]*num_butterflies
upside_list = [None]*num_butterflies
recent_5day_pnl_list = [None]*num_butterflies
recent_vol_ratio_list = [None]*num_butterflies
theo_pnl_list = [None]*num_butterflies
theo_pnl5_list = [None]*num_butterflies
theo_pnl10_list = [None]*num_butterflies
theo_pnl15_list = [None]*num_butterflies
theo_pnl20_list = [None]*num_butterflies
theo_pnl25_list = [None]*num_butterflies
ratio_target5_list = [None]*num_butterflies
ratio_target10_list = [None]*num_butterflies
ratio_target15_list = [None]*num_butterflies
ratio_target20_list = [None]*num_butterflies
ratio_target25_list = [None]*num_butterflies
price_1_list = [None]*num_butterflies
price_2_list = [None]*num_butterflies
price_3_list = [None]*num_butterflies
mean_reversion_rsquared_list = [None]*num_butterflies
mean_reversion_signif_list = [None]*num_butterflies
futures_data_dictionary = {x: gfp.get_futures_price_preloaded(ticker_head=x) for x in cmi.futures_butterfly_strategy_tickerhead_list}
date5_years_ago = cu.doubledate_shift(date_to,5*365)
datetime5_years_ago = cu.convert_doubledate_2datetime(date5_years_ago)
for i in range(num_butterflies):
bf_signals_output = fs.get_futures_butterfly_signals(ticker_list=[butterflies['ticker1'][i], butterflies['ticker2'][i], butterflies['ticker3'][i]],
tr_dte_list=[butterflies['trDte1'][i], butterflies['trDte2'][i], butterflies['trDte3'][i]],
aggregation_method=butterflies['agg'][i],
contracts_back=butterflies['cBack'][i],
date_to=date_to,
futures_data_dictionary=futures_data_dictionary,
contract_multiplier=butterflies['multiplier'][i],
datetime5_years_ago=datetime5_years_ago)
q_list[i] = bf_signals_output['q']
qf_list[i] = bf_signals_output['qf']
zscore1_list[i] = bf_signals_output['zscore1']
zscore2_list[i] = bf_signals_output['zscore2']
zscore3_list[i] = bf_signals_output['zscore3']
zscore4_list[i] = bf_signals_output['zscore4']
zscore5_list[i] = bf_signals_output['zscore5']
zscore6_list[i] = bf_signals_output['zscore6']
zscore7_list[i] = bf_signals_output['zscore7']
rsquared1_list[i] = bf_signals_output['rsquared1']
rsquared2_list[i] = bf_signals_output['rsquared2']
regime_change_list[i] = bf_signals_output['regime_change_ind']
contract_seasonality_list[i] = bf_signals_output['contract_seasonality_ind']
yield1_list[i] = bf_signals_output['yield1_current']
yield2_list[i] = bf_signals_output['yield2_current']
bf_price_list[i] = bf_signals_output['bf_price']
bf_price_sell_limit_list[i] = bf_signals_output['short_price_limit']
bf_price_buy_limit_list[i] = bf_signals_output['long_price_limit']
noise_ratio_list[i] = bf_signals_output['noise_ratio']
alpha1_list[i] = bf_signals_output['alpha1']
alpha2_list[i] = bf_signals_output['alpha2']
residual_std1_list = bf_signals_output['residual_std1']
residual_std2_list = bf_signals_output['residual_std2']
second_spread_weight_1_list[i] = bf_signals_output['second_spread_weight_1']
second_spread_weight_2_list[i] = bf_signals_output['second_spread_weight_2']
weight1_list[i] = bf_signals_output['weight1']
weight2_list[i] = bf_signals_output['weight2']
weight3_list[i] = bf_signals_output['weight3']
downside_list[i] = bf_signals_output['downside']
upside_list[i] = bf_signals_output['upside']
recent_5day_pnl_list[i] = bf_signals_output['recent_5day_pnl']
recent_vol_ratio_list[i] = bf_signals_output['recent_vol_ratio']
theo_pnl_list[i] = bf_signals_output['theo_pnl']
theo_pnl5_list[i] = bf_signals_output['theo_pnl_list'][0]
theo_pnl10_list[i] = bf_signals_output['theo_pnl_list'][1]
theo_pnl15_list[i] = bf_signals_output['theo_pnl_list'][2]
theo_pnl20_list[i] = bf_signals_output['theo_pnl_list'][3]
theo_pnl25_list[i] = bf_signals_output['theo_pnl_list'][4]
ratio_target5_list[i] = bf_signals_output['ratio_target_list'][0]
ratio_target10_list[i] = bf_signals_output['ratio_target_list'][1]
ratio_target15_list[i] = bf_signals_output['ratio_target_list'][2]
ratio_target20_list[i] = bf_signals_output['ratio_target_list'][3]
ratio_target25_list[i] = bf_signals_output['ratio_target_list'][4]
price_1_list[i] = bf_signals_output['price_1']
price_2_list[i] = bf_signals_output['price_2']
price_3_list[i] = bf_signals_output['price_3']
mean_reversion_rsquared_list[i] = bf_signals_output['mean_reversion_rsquared']
mean_reversion_signif_list[i] = bf_signals_output['mean_reversion_signif']
butterflies['Q'] = q_list
butterflies['QF'] = qf_list
butterflies['z1'] = zscore1_list
butterflies['z2'] = zscore2_list
butterflies['z3'] = zscore3_list
butterflies['z4'] = zscore4_list
butterflies['z5'] = zscore5_list
butterflies['z6'] = zscore6_list
butterflies['z7'] = zscore7_list
butterflies['r1'] = rsquared1_list
butterflies['r2'] = rsquared2_list
butterflies['RC'] = regime_change_list
butterflies['seasonality'] = contract_seasonality_list
butterflies['yield1'] = yield1_list
butterflies['yield2'] = yield2_list
butterflies['bf_price'] = bf_price_list
butterflies['bf_sell_limit'] = bf_price_sell_limit_list
butterflies['bf_buy_limit'] = bf_price_buy_limit_list
butterflies['noise_ratio'] = noise_ratio_list
butterflies['alpha1'] = alpha1_list
butterflies['alpha2'] = alpha2_list
butterflies['residual_std1'] = residual_std1_list
butterflies['residual_std2'] = residual_std2_list
butterflies['second_spread_weight_1'] = second_spread_weight_1_list
butterflies['second_spread_weight_2'] = second_spread_weight_2_list
butterflies['weight1'] = weight1_list
butterflies['weight2'] = weight2_list
butterflies['weight3'] = weight3_list
butterflies['downside'] = downside_list
butterflies['upside'] = upside_list
butterflies['recent_5day_pnl'] = recent_5day_pnl_list
butterflies['recent_vol_ratio'] = recent_vol_ratio_list
butterflies['theo_pnl'] = theo_pnl_list
butterflies['theo_pnl5'] = theo_pnl5_list
butterflies['theo_pnl10'] = theo_pnl10_list
butterflies['theo_pnl15'] = theo_pnl15_list
butterflies['theo_pnl20'] = theo_pnl20_list
butterflies['theo_pnl25'] = theo_pnl25_list
butterflies['ratio_target5'] = ratio_target5_list
butterflies['ratio_target10'] = ratio_target10_list
butterflies['ratio_target15'] = ratio_target15_list
butterflies['ratio_target20'] = ratio_target20_list
butterflies['ratio_target25'] = ratio_target25_list
butterflies['price1'] = price_1_list
butterflies['price2'] = price_2_list
butterflies['price3'] = price_3_list
butterflies['mean_reversion_rsquared'] = mean_reversion_rsquared_list
butterflies['mean_reversion_signif'] = mean_reversion_signif_list
butterflies['z1'] = butterflies['z1'].round(2)
butterflies['z2'] = butterflies['z2'].round(2)
butterflies['z3'] = butterflies['z3'].round(2)
butterflies['z4'] = butterflies['z4'].round(2)
butterflies['z5'] = butterflies['z5'].round(2)
butterflies['z6'] = butterflies['z6'].round(2)
butterflies['z7'] = butterflies['z7'].round(2)
butterflies['r1'] = butterflies['r1'].round(2)
butterflies['r2'] = butterflies['r2'].round(2)
butterflies['RC'] = butterflies['RC'].round(2)
butterflies['seasonality'] = butterflies['seasonality'].round(2)
butterflies['second_spread_weight_1'] = butterflies['second_spread_weight_1'].round(2)
butterflies['second_spread_weight_2'] = butterflies['second_spread_weight_1'].round(2)
butterflies['yield1'] = butterflies['yield1'].round(3)
butterflies['yield2'] = butterflies['yield2'].round(3)
butterflies['noise_ratio'] = butterflies['noise_ratio'].round(3)
butterflies['alpha1'] = butterflies['alpha1'].round(3)
butterflies['alpha2'] = butterflies['alpha2'].round(3)
butterflies['residual_std1'] = butterflies['residual_std1'].round(3)
butterflies['residual_std2'] = butterflies['residual_std2'].round(3)
butterflies['downside'] = butterflies['downside'].round(3)
butterflies['upside'] = butterflies['upside'].round(3)
butterflies['recent_5day_pnl'] = butterflies['recent_5day_pnl'].round(3)
butterflies['recent_vol_ratio'] = butterflies['recent_vol_ratio'].round(2)
butterflies['theo_pnl'] = butterflies['theo_pnl'].round(3)
butterflies['price1'] = butterflies['price1'].round(4)
butterflies['price2'] = butterflies['price2'].round(4)
butterflies['price3'] = butterflies['price3'].round(4)
butterflies['mean_reversion_rsquared'] = butterflies['mean_reversion_rsquared'].round(2)
butterflies.to_pickle(output_dir + '/summary.pkl')
return {'butterflies': butterflies,'success': True}
def backtest_ifs_4date(**kwargs):
report_date = kwargs['report_date']
output_dir = ts.create_strategy_output_dir(strategy_class='ifs', report_date=report_date)
#if os.path.isfile(output_dir + '/backtest_results.pkl'):
# intraday_spreads = pd.read_pickle(output_dir + '/backtest_results.pkl')
# return intraday_spreads
start_hour = dt.time(9, 0, 0, 0)
end_hour = dt.time(12, 55, 0, 0)
sheet_output = ifs.generate_ifs_sheet_4date(date_to=report_date)
intraday_spreads = sheet_output['intraday_spreads']
intraday_spreads['pnl1'] = 0
intraday_spreads['pnl2'] = 0
intraday_spreads['pnl5'] = 0
intraday_spreads['pnl6'] = 0
intraday_spreads['pnl7'] = 0
intraday_spreads['pnl1_wc'] = 0
intraday_spreads['pnl2_wc'] = 0
intraday_spreads['pnl5_wc'] = 0
intraday_spreads['pnl6_wc'] = 0
intraday_spreads['pnl7_wc'] = 0
intraday_spreads['report_date'] = report_date
intraday_spreads['spread_description'] = intraday_spreads.apply(lambda x: x['ticker_head1']+ '_' +x['ticker_head2'] if x['ticker_head3'] is None else x['ticker_head1']+ '_' +x['ticker_head2'] + '_' + x['ticker_head3'] ,axis=1)
intraday_spreads['min_volume'] = intraday_spreads.apply(lambda x: min(x['volume1'],x['volume2']) if x['ticker_head3'] is None else min(x['volume1'],x['volume2'],x['volume3']) ,axis=1)
intraday_spreads.sort(['spread_description','min_volume'],ascending=[True, False],inplace=True)
intraday_spreads.drop_duplicates('spread_description',inplace=True)
intraday_spreads = intraday_spreads[intraday_spreads['hs']>-1]
intraday_spreads.reset_index(drop=True,inplace=True)
date_list = [exp.doubledate_shift_bus_days(double_date=report_date, shift_in_days=x) for x in [-1,-2]]
for i in range(len(intraday_spreads.index)):
#print(i)
ticker_list = [intraday_spreads.iloc[i]['contract1'],intraday_spreads.iloc[i]['contract2'],intraday_spreads.iloc[i]['contract3']]
ticker_list = [x for x in ticker_list if x is not None]
ticker_head_list = [cmi.get_contract_specs(x)['ticker_head'] for x in ticker_list]
num_contracts = len(ticker_list)
weights_output = sutil.get_spread_weights_4contract_list(ticker_head_list=ticker_head_list)
contract_multiplier_list = [cmi.contract_multiplier[x] for x in ticker_head_list]
spread_weights = weights_output['spread_weights']
intraday_data = opUtil.get_aligned_futures_data_intraday(contract_list=ticker_list,
date_list=date_list)
intraday_data['spread'] = 0
for j in range(num_contracts):
intraday_data['c' + str(j+1), 'mid_p'] = (intraday_data['c' + str(j+1)]['best_bid_p'] +
intraday_data['c' + str(j+1)]['best_ask_p'])/2
intraday_data['spread'] = intraday_data['spread']+intraday_data['c' + str(j+1)]['mid_p']*spread_weights[j]
selection_indx = [x for x in range(len(intraday_data.index)) if
(intraday_data.index[x].to_datetime().time() < end_hour)
and(intraday_data.index[x].to_datetime().time() >= start_hour)]
intraday_data = intraday_data.iloc[selection_indx]
intraday_data['time_stamp'] = [x.to_datetime() for x in intraday_data.index]
intraday_data['settle_date'] = intraday_data['time_stamp'].apply(lambda x: x.date())
unique_settle_dates = intraday_data['settle_date'].unique()
intraday_data['spread1'] = np.nan
if len(unique_settle_dates)<2:
continue
final_spread_price = np.mean(intraday_data['spread'][(intraday_data['settle_date'] == unique_settle_dates[1])])
intraday_data = intraday_data[(intraday_data['settle_date'] == unique_settle_dates[0])]
intraday_data['spread_diff'] = contract_multiplier_list[0]*(final_spread_price-intraday_data['spread'])/spread_weights[0]
mean5 = intraday_spreads.iloc[i]['mean']
std5 = intraday_spreads.iloc[i]['std']
mean1 = intraday_spreads.iloc[i]['mean1']
std1 = intraday_spreads.iloc[i]['std1']
mean2 = intraday_spreads.iloc[i]['mean2']
std2 = intraday_spreads.iloc[i]['std2']
long_qty = -5000/intraday_spreads.iloc[i]['downside']
short_qty = -5000/intraday_spreads.iloc[i]['upside']
intraday_data['z5'] = (intraday_data['spread']-mean5)/std5
intraday_data['z1'] = (intraday_data['spread']-mean1)/std1
intraday_data['z2'] = (intraday_data['spread']-mean2)/std2
intraday_data['z6'] = (intraday_data['spread']-mean1)/std5
intraday_data11 = intraday_data[intraday_data['z1']>1]
intraday_data1_1 = intraday_data[intraday_data['z1']<-1]
if intraday_data1_1.empty:
pnl1_1 = 0
pnl1_1_wc = 0
else:
pnl1_1 = long_qty*intraday_data1_1['spread_diff'].mean()
pnl1_1_wc = pnl1_1 - 2*2*long_qty*num_contracts
if intraday_data11.empty:
pnl11 = 0
pnl11_wc = 0
else:
pnl11 = short_qty*intraday_data11['spread_diff'].mean()
pnl11_wc = pnl11 + 2*2*short_qty*num_contracts
intraday_data21 = intraday_data[intraday_data['z2']>1]
intraday_data2_1 = intraday_data[intraday_data['z2']<-1]
if intraday_data2_1.empty:
pnl2_1 = 0
pnl2_1_wc = 0
else:
pnl2_1 = long_qty*intraday_data2_1['spread_diff'].mean()
pnl2_1_wc = pnl2_1 - 2*2*long_qty*num_contracts
if intraday_data21.empty:
pnl21 = 0
pnl21_wc = 0
else:
pnl21 = short_qty*intraday_data21['spread_diff'].mean()
pnl21_wc = pnl21 + 2*2*short_qty*num_contracts
intraday_data51 = intraday_data[intraday_data['z5']>1]
intraday_data5_1 = intraday_data[intraday_data['z5']<-1]
if intraday_data5_1.empty:
pnl5_1 = 0
pnl5_1_wc = 0
else:
pnl5_1 = long_qty*intraday_data5_1['spread_diff'].mean()
pnl5_1_wc = pnl5_1 - 2*2*long_qty*num_contracts
if intraday_data51.empty:
pnl51 = 0
pnl51_wc = 0
else:
pnl51 = short_qty*intraday_data51['spread_diff'].mean()
pnl51_wc = pnl51 + 2*2*short_qty*num_contracts
intraday_data61 = intraday_data[intraday_data['z6']>0.25]
intraday_data6_1 = intraday_data[intraday_data['z6']<-0.25]
if intraday_data6_1.empty:
pnl6_1 = 0
pnl6_1_wc = 0
else:
pnl6_1 = long_qty*intraday_data6_1['spread_diff'].mean()
pnl6_1_wc = pnl6_1 - 2*2*long_qty*num_contracts
if intraday_data61.empty:
pnl61 = 0
pnl61_wc = 0
else:
pnl61 = short_qty*intraday_data61['spread_diff'].mean()
pnl61_wc = pnl61 + 2*2*short_qty*num_contracts
intraday_data71 = intraday_data[(intraday_data['z6']>0.1)&(intraday_data['z5']>0.5)]
intraday_data7_1 = intraday_data[(intraday_data['z6']<-0.1)&(intraday_data['z5']<0.5)]
if intraday_data7_1.empty:
pnl7_1 = 0
pnl7_1_wc = 0
else:
pnl7_1 = long_qty*intraday_data7_1['spread_diff'].mean()
pnl7_1_wc = pnl7_1 - 2*2*long_qty*num_contracts
if intraday_data71.empty:
pnl71 = 0
pnl71_wc = 0
else:
pnl71 = short_qty*intraday_data71['spread_diff'].mean()
pnl71_wc = pnl71 + 2*2*short_qty*num_contracts
intraday_spreads['pnl1'].iloc[i] = pnl1_1 + pnl11
intraday_spreads['pnl2'].iloc[i] = pnl2_1 + pnl21
intraday_spreads['pnl5'].iloc[i] = pnl5_1 + pnl51
intraday_spreads['pnl6'].iloc[i] = pnl6_1 + pnl61
intraday_spreads['pnl7'].iloc[i] = pnl7_1 + pnl71
intraday_spreads['pnl1_wc'].iloc[i] = pnl1_1_wc + pnl11_wc
intraday_spreads['pnl2_wc'].iloc[i] = pnl2_1_wc + pnl21_wc
intraday_spreads['pnl5_wc'].iloc[i] = pnl5_1_wc + pnl51_wc
intraday_spreads['pnl6_wc'].iloc[i] = pnl6_1_wc + pnl61_wc
intraday_spreads['pnl7_wc'].iloc[i] = pnl7_1_wc + pnl71_wc
intraday_spreads.to_pickle(output_dir + '/backtest_results.pkl')
return intraday_spreads
def generate_vcs_sheet_4date(**kwargs):
kwargs['settle_date'] = kwargs['date_to']
num_cal_days_back = 20*365
output_dir = ts.create_strategy_output_dir(strategy_class='vcs', report_date=kwargs['date_to'])
if os.path.isfile(output_dir + '/summary.pkl'):
vcs_pairs = pd.read_pickle(output_dir + '/summary.pkl')
return {'vcs_pairs': vcs_pairs,'success': True}
vcs_pairs = get_vcs_pairs_4date(**kwargs)
num_pairs = len(vcs_pairs.index)
unique_ticker_heads = list(set(vcs_pairs['tickerHead']))
con = msu.get_my_sql_connection(**kwargs)
option_ticker_indicator_dictionary = {x: ops.get_option_ticker_indicators(ticker_head=x,
settle_date_to=kwargs['date_to'],
num_cal_days_back=num_cal_days_back,
con=con) for x in unique_ticker_heads}
if 'con' not in kwargs.keys():
con.close()
q_list = [None]*num_pairs
q1_list = [None]*num_pairs
fwd_vol_q_list = [None]*num_pairs
downside_list = [None]*num_pairs
upside_list = [None]*num_pairs
atm_vol_ratio_list = [None]*num_pairs
real_vol_ratio_list = [None]*num_pairs
atm_real_vol_ratio_list = [None]*num_pairs
theta_list = [None]*num_pairs
fwd_vol = [None]*num_pairs
for i in range(num_pairs):
vcs_output = ops.get_vcs_signals(ticker_list=[vcs_pairs['ticker1'].iloc[i], vcs_pairs['ticker2'].iloc[i]],
option_ticker_indicator_dictionary=option_ticker_indicator_dictionary,
settle_date=kwargs['date_to'])
q_list[i] = vcs_output['q']
q1_list[i] = vcs_output['q1']
fwd_vol_q_list[i] = vcs_output['fwd_vol_q']
downside_list[i] = vcs_output['downside']
upside_list[i] = vcs_output['upside']
atm_vol_ratio_list[i] = vcs_output['atm_vol_ratio']
fwd_vol[i] = vcs_output['fwd_vol']
real_vol_ratio_list[i] = vcs_output['real_vol_ratio']
atm_real_vol_ratio_list[i] = vcs_output['atm_real_vol_ratio']
theta_list[i] = vcs_output['theta']
vcs_pairs['Q'] = q_list
vcs_pairs['Q1'] = q1_list
vcs_pairs['fwdVolQ'] = fwd_vol_q_list
vcs_pairs['downside'] = downside_list
vcs_pairs['upside'] = upside_list
vcs_pairs['atmVolRatio'] = atm_vol_ratio_list
vcs_pairs['fwdVol'] = fwd_vol
vcs_pairs['realVolRatio'] = real_vol_ratio_list
vcs_pairs['atmRealVolRatio'] = atm_real_vol_ratio_list
vcs_pairs['theta'] = theta_list
vcs_pairs['downside'] = vcs_pairs['downside'].round(3)
vcs_pairs['upside'] = vcs_pairs['upside'].round(3)
vcs_pairs['atmVolRatio'] = vcs_pairs['atmVolRatio'].round(3)
vcs_pairs['fwdVol'] = vcs_pairs['fwdVol'].round(3)
vcs_pairs['realVolRatio'] = vcs_pairs['realVolRatio'].round(3)
vcs_pairs['atmRealVolRatio'] = vcs_pairs['atmRealVolRatio'].round(3)
vcs_pairs['theta'] = vcs_pairs['theta'].round(3)
vcs_pairs.to_pickle(output_dir + '/summary.pkl')
return {'vcs_pairs': vcs_pairs,'success': True}
def generate_overnight_spreads_sheet_4date(**kwargs):
date_to = kwargs['date_to']
output_dir = ts.create_strategy_output_dir(strategy_class='ocs',
report_date=date_to)
if os.path.isfile(output_dir + '/summary.pkl'):
overnight_calendars = pd.read_pickle(output_dir + '/summary.pkl')
return {'overnight_calendars': overnight_calendars, 'success': True}
if 'volume_filter' not in kwargs.keys():
kwargs['volume_filter'] = 50
overnight_calendars = get_overnight_spreads_4date(**kwargs)
futures_data_dictionary = {
x: gfp.get_futures_price_preloaded(ticker_head=x)
for x in overnight_calendars['tickerHead']
}
num_spreads = len(overnight_calendars.index)
signals_output = [
ocss.get_overnight_calendar_signals(
ticker_list=[
overnight_calendars.iloc[x]['ticker1'],
overnight_calendars.iloc[x]['ticker2']
],
futures_data_dictionary=futures_data_dictionary,
date_to=date_to) for x in range(num_spreads)
]
overnight_calendars['ticker1L'] = [x['ticker1L'] for x in signals_output]
overnight_calendars['ticker2L'] = [x['ticker2L'] for x in signals_output]
overnight_calendars['qCarry'] = [x['q_carry'] for x in signals_output]
overnight_calendars['butterflyQ'] = [
x['butterfly_q'] for x in signals_output
]
overnight_calendars['butterflyZ'] = [
x['butterfly_z'] for x in signals_output
]
overnight_calendars['spreadPrice'] = [
x['spread_price'] for x in signals_output
]
overnight_calendars['butterfly_q10'] = [
x['butterfly_q10'] for x in signals_output
]
overnight_calendars['butterfly_q25'] = [
x['butterfly_q25'] for x in signals_output
]
overnight_calendars['butterfly_q35'] = [
x['butterfly_q35'] for x in signals_output
]
overnight_calendars['butterfly_q50'] = [
x['butterfly_q50'] for x in signals_output
]
overnight_calendars['butterfly_q65'] = [
x['butterfly_q65'] for x in signals_output
]
overnight_calendars['butterfly_q75'] = [
x['butterfly_q75'] for x in signals_output
]
overnight_calendars['butterfly_q90'] = [
x['butterfly_q90'] for x in signals_output
]
overnight_calendars['butterflyMean'] = [
x['butterfly_mean'] for x in signals_output
]
overnight_calendars['butterflyNoise'] = [
x['butterfly_noise'] for x in signals_output
]
overnight_calendars['noise100'] = [x['noise_100'] for x in signals_output]
overnight_calendars['dollarNoise100'] = [
x['dollar_noise_100'] for x in signals_output
]
overnight_calendars['pnl1'] = [x['pnl1'] for x in signals_output]
overnight_calendars['pnl1_instant'] = [
x['pnl1_instant'] for x in signals_output
]
overnight_calendars['pnl2'] = [x['pnl2'] for x in signals_output]
overnight_calendars['pnl5'] = [x['pnl5'] for x in signals_output]
overnight_calendars['pnl10'] = [x['pnl10'] for x in signals_output]
overnight_calendars.to_pickle(output_dir + '/summary.pkl')
return {'overnight_calendars': overnight_calendars, 'success': True}
def generate_futures_butterfly_sheet_4date(**kwargs):
date_to = kwargs['date_to']
output_dir = ts.create_strategy_output_dir(
strategy_class='futures_butterfly', report_date=date_to)
if os.path.isfile(output_dir + '/summary.pkl'):
butterflies = pd.read_pickle(output_dir + '/summary.pkl')
return {'butterflies': butterflies, 'success': True}
if 'volume_filter' not in kwargs.keys():
kwargs['volume_filter'] = 100
butterflies = get_futures_butterflies_4date(**kwargs)
butterflies = butterflies[butterflies['trDte1'] >= 35]
butterflies.reset_index(drop=True, inplace=True)
num_butterflies = len(butterflies)
q_list = [None] * num_butterflies
qf_list = [None] * num_butterflies
zscore1_list = [None] * num_butterflies
zscore2_list = [None] * num_butterflies
zscore3_list = [None] * num_butterflies
zscore4_list = [None] * num_butterflies
zscore5_list = [None] * num_butterflies
zscore6_list = [None] * num_butterflies
zscore7_list = [None] * num_butterflies
rsquared1_list = [None] * num_butterflies
rsquared2_list = [None] * num_butterflies
regime_change_list = [None] * num_butterflies
contract_seasonality_list = [None] * num_butterflies
yield1_list = [None] * num_butterflies
yield2_list = [None] * num_butterflies
bf_price_list = [None] * num_butterflies
bf_price_sell_limit_list = [None] * num_butterflies
bf_price_buy_limit_list = [None] * num_butterflies
noise_ratio_list = [None] * num_butterflies
alpha1_list = [None] * num_butterflies
alpha2_list = [None] * num_butterflies
residual_std1_list = [None] * num_butterflies
residual_std2_list = [None] * num_butterflies
second_spread_weight_1_list = [None] * num_butterflies
second_spread_weight_2_list = [None] * num_butterflies
weight1_list = [None] * num_butterflies
weight2_list = [None] * num_butterflies
weight3_list = [None] * num_butterflies
downside_list = [None] * num_butterflies
upside_list = [None] * num_butterflies
recent_5day_pnl_list = [None] * num_butterflies
recent_vol_ratio_list = [None] * num_butterflies
theo_pnl_list = [None] * num_butterflies
theo_pnl5_list = [None] * num_butterflies
theo_pnl10_list = [None] * num_butterflies
theo_pnl15_list = [None] * num_butterflies
theo_pnl20_list = [None] * num_butterflies
theo_pnl25_list = [None] * num_butterflies
ratio_target5_list = [None] * num_butterflies
ratio_target10_list = [None] * num_butterflies
ratio_target15_list = [None] * num_butterflies
ratio_target20_list = [None] * num_butterflies
ratio_target25_list = [None] * num_butterflies
price_1_list = [None] * num_butterflies
price_2_list = [None] * num_butterflies
price_3_list = [None] * num_butterflies
mean_reversion_rsquared_list = [None] * num_butterflies
mean_reversion_signif_list = [None] * num_butterflies
futures_data_dictionary = {
x: gfp.get_futures_price_preloaded(ticker_head=x)
for x in cmi.futures_butterfly_strategy_tickerhead_list
}
date5_years_ago = cu.doubledate_shift(date_to, 5 * 365)
datetime5_years_ago = cu.convert_doubledate_2datetime(date5_years_ago)
for i in range(num_butterflies):
bf_signals_output = fs.get_futures_butterfly_signals(
ticker_list=[
butterflies['ticker1'][i], butterflies['ticker2'][i],
butterflies['ticker3'][i]
],
tr_dte_list=[
butterflies['trDte1'][i], butterflies['trDte2'][i],
butterflies['trDte3'][i]
],
aggregation_method=butterflies['agg'][i],
contracts_back=butterflies['cBack'][i],
date_to=date_to,
futures_data_dictionary=futures_data_dictionary,
contract_multiplier=butterflies['multiplier'][i],
datetime5_years_ago=datetime5_years_ago)
if not bf_signals_output['success']:
continue
q_list[i] = bf_signals_output['q']
qf_list[i] = bf_signals_output['qf']
zscore1_list[i] = bf_signals_output['zscore1']
zscore2_list[i] = bf_signals_output['zscore2']
zscore3_list[i] = bf_signals_output['zscore3']
zscore4_list[i] = bf_signals_output['zscore4']
zscore5_list[i] = bf_signals_output['zscore5']
zscore6_list[i] = bf_signals_output['zscore6']
zscore7_list[i] = bf_signals_output['zscore7']
rsquared1_list[i] = bf_signals_output['rsquared1']
rsquared2_list[i] = bf_signals_output['rsquared2']
regime_change_list[i] = bf_signals_output['regime_change_ind']
contract_seasonality_list[i] = bf_signals_output[
'contract_seasonality_ind']
yield1_list[i] = bf_signals_output['yield1_current']
yield2_list[i] = bf_signals_output['yield2_current']
bf_price_list[i] = bf_signals_output['bf_price']
bf_price_sell_limit_list[i] = bf_signals_output['short_price_limit']
bf_price_buy_limit_list[i] = bf_signals_output['long_price_limit']
noise_ratio_list[i] = bf_signals_output['noise_ratio']
alpha1_list[i] = bf_signals_output['alpha1']
alpha2_list[i] = bf_signals_output['alpha2']
residual_std1_list = bf_signals_output['residual_std1']
residual_std2_list = bf_signals_output['residual_std2']
second_spread_weight_1_list[i] = bf_signals_output[
'second_spread_weight_1']
second_spread_weight_2_list[i] = bf_signals_output[
'second_spread_weight_2']
weight1_list[i] = bf_signals_output['weight1']
weight2_list[i] = bf_signals_output['weight2']
weight3_list[i] = bf_signals_output['weight3']
downside_list[i] = bf_signals_output['downside']
upside_list[i] = bf_signals_output['upside']
recent_5day_pnl_list[i] = bf_signals_output['recent_5day_pnl']
recent_vol_ratio_list[i] = bf_signals_output['recent_vol_ratio']
theo_pnl_list[i] = bf_signals_output['theo_pnl']
theo_pnl5_list[i] = bf_signals_output['theo_pnl_list'][0]
theo_pnl10_list[i] = bf_signals_output['theo_pnl_list'][1]
theo_pnl15_list[i] = bf_signals_output['theo_pnl_list'][2]
theo_pnl20_list[i] = bf_signals_output['theo_pnl_list'][3]
theo_pnl25_list[i] = bf_signals_output['theo_pnl_list'][4]
ratio_target5_list[i] = bf_signals_output['ratio_target_list'][0]
ratio_target10_list[i] = bf_signals_output['ratio_target_list'][1]
ratio_target15_list[i] = bf_signals_output['ratio_target_list'][2]
ratio_target20_list[i] = bf_signals_output['ratio_target_list'][3]
ratio_target25_list[i] = bf_signals_output['ratio_target_list'][4]
price_1_list[i] = bf_signals_output['price_1']
price_2_list[i] = bf_signals_output['price_2']
price_3_list[i] = bf_signals_output['price_3']
mean_reversion_rsquared_list[i] = bf_signals_output[
'mean_reversion_rsquared']
mean_reversion_signif_list[i] = bf_signals_output[
'mean_reversion_signif']
butterflies['Q'] = q_list
butterflies['QF'] = qf_list
butterflies['z1'] = zscore1_list
butterflies['z2'] = zscore2_list
butterflies['z3'] = zscore3_list
butterflies['z4'] = zscore4_list
butterflies['z5'] = zscore5_list
butterflies['z6'] = zscore6_list
butterflies['z7'] = zscore7_list
butterflies['r1'] = rsquared1_list
butterflies['r2'] = rsquared2_list
butterflies['RC'] = regime_change_list
butterflies['seasonality'] = contract_seasonality_list
butterflies['yield1'] = yield1_list
butterflies['yield2'] = yield2_list
butterflies['bf_price'] = bf_price_list
butterflies['bf_sell_limit'] = bf_price_sell_limit_list
butterflies['bf_buy_limit'] = bf_price_buy_limit_list
butterflies['noise_ratio'] = noise_ratio_list
butterflies['alpha1'] = alpha1_list
butterflies['alpha2'] = alpha2_list
butterflies['residual_std1'] = residual_std1_list
butterflies['residual_std2'] = residual_std2_list
butterflies['second_spread_weight_1'] = second_spread_weight_1_list
butterflies['second_spread_weight_2'] = second_spread_weight_2_list
butterflies['weight1'] = weight1_list
butterflies['weight2'] = weight2_list
butterflies['weight3'] = weight3_list
butterflies['downside'] = downside_list
butterflies['upside'] = upside_list
butterflies['recent_5day_pnl'] = recent_5day_pnl_list
butterflies['recent_vol_ratio'] = recent_vol_ratio_list
butterflies['theo_pnl'] = theo_pnl_list
butterflies['theo_pnl5'] = theo_pnl5_list
butterflies['theo_pnl10'] = theo_pnl10_list
butterflies['theo_pnl15'] = theo_pnl15_list
butterflies['theo_pnl20'] = theo_pnl20_list
butterflies['theo_pnl25'] = theo_pnl25_list
butterflies['ratio_target5'] = ratio_target5_list
butterflies['ratio_target10'] = ratio_target10_list
butterflies['ratio_target15'] = ratio_target15_list
butterflies['ratio_target20'] = ratio_target20_list
butterflies['ratio_target25'] = ratio_target25_list
butterflies['price1'] = price_1_list
butterflies['price2'] = price_2_list
butterflies['price3'] = price_3_list
butterflies['mean_reversion_rsquared'] = mean_reversion_rsquared_list
butterflies['mean_reversion_signif'] = mean_reversion_signif_list
butterflies['z1'] = butterflies['z1'].round(2)
butterflies['z2'] = butterflies['z2'].round(2)
butterflies['z3'] = butterflies['z3'].round(2)
butterflies['z4'] = butterflies['z4'].round(2)
butterflies['z5'] = butterflies['z5'].round(2)
butterflies['z6'] = butterflies['z6'].round(2)
butterflies['z7'] = butterflies['z7'].round(2)
butterflies['r1'] = butterflies['r1'].round(2)
butterflies['r2'] = butterflies['r2'].round(2)
butterflies['RC'] = butterflies['RC'].round(2)
butterflies['seasonality'] = butterflies['seasonality'].round(2)
butterflies['second_spread_weight_1'] = butterflies[
'second_spread_weight_1'].round(2)
butterflies['second_spread_weight_2'] = butterflies[
'second_spread_weight_1'].round(2)
butterflies['yield1'] = butterflies['yield1'].round(3)
butterflies['yield2'] = butterflies['yield2'].round(3)
butterflies['noise_ratio'] = butterflies['noise_ratio'].round(3)
butterflies['alpha1'] = butterflies['alpha1'].round(3)
butterflies['alpha2'] = butterflies['alpha2'].round(3)
butterflies['residual_std1'] = butterflies['residual_std1'].round(3)
butterflies['residual_std2'] = butterflies['residual_std2'].round(3)
butterflies['downside'] = butterflies['downside'].round(3)
butterflies['upside'] = butterflies['upside'].round(3)
butterflies['recent_5day_pnl'] = butterflies['recent_5day_pnl'].round(3)
butterflies['recent_vol_ratio'] = butterflies['recent_vol_ratio'].round(2)
butterflies['theo_pnl'] = butterflies['theo_pnl'].round(3)
butterflies['price1'] = butterflies['price1'].round(4)
butterflies['price2'] = butterflies['price2'].round(4)
butterflies['price3'] = butterflies['price3'].round(4)
butterflies['mean_reversion_rsquared'] = butterflies[
'mean_reversion_rsquared'].round(2)
butterflies.to_pickle(output_dir + '/summary.pkl')
return {'butterflies': butterflies, 'success': True}
def get_curve_pca_report(**kwargs):
ticker_head = kwargs['ticker_head']
date_to = kwargs['date_to']
if 'use_existing_filesQ' in kwargs.keys():
use_existing_filesQ = kwargs['use_existing_filesQ']
else:
use_existing_filesQ = True
output_dir = ts.create_strategy_output_dir(strategy_class='curve_pca', report_date=date_to)
if os.path.isfile(output_dir + '/' + ticker_head + '.pkl') and use_existing_filesQ:
pca_results = pd.read_pickle(output_dir + '/' + ticker_head + '.pkl')
return {'pca_results': pca_results, 'success': True}
date10_years_ago = cu.doubledate_shift(date_to, 10*365)
datetime_to = cu.convert_doubledate_2datetime(date_to)
if ticker_head == 'ED':
num_contracts = 12
rolling_data = cd.get_rolling_curve_data(ticker_head=ticker_head, num_contracts=num_contracts,
front_tr_dte_limit=10,
date_from=date10_years_ago,
date_to=date_to)
if datetime_to != rolling_data[0].index[-1].to_datetime():
return {'pca_results': pd.DataFrame(), 'success': False}
merged_data = pd.concat(rolling_data, axis=1, join='inner')
total_range = list(range(len(rolling_data)))
index_exclude = [len(total_range)-1]
month_spread = [3]*(len(rolling_data)-1)
elif ticker_head in ['CL', 'B']:
num_monthly_contracts = 18
if ticker_head == 'CL':
num_semiannual_contracts = 6
elif ticker_head == 'B':
num_semiannual_contracts = 7
rolling_data_monthly = cd.get_rolling_curve_data(ticker_head=ticker_head, num_contracts=num_monthly_contracts,
front_tr_dte_limit=10,
date_from=date10_years_ago,
date_to=date_to)
rolling_data_semiannual = cd.get_rolling_curve_data(ticker_head=ticker_head, num_contracts=num_semiannual_contracts,
front_tr_dte_limit=10,
date_from=date10_years_ago,
month_separation=6,
date_to=date_to)
if datetime_to != rolling_data_monthly[0].index[-1].to_datetime() or datetime_to != rolling_data_semiannual[0].index[-1].to_datetime():
return {'pca_results': pd.DataFrame(), 'success': False}
rolling_data_merged = pd.concat(rolling_data_semiannual, axis=1)
annual_select = rolling_data_merged['ticker_month'].iloc[-1] % 12 == 0
rolling_data_annual = [rolling_data_semiannual[x] for x in range(len(rolling_data_semiannual)) if annual_select.values[x]]
merged_data = pd.concat(rolling_data_monthly+rolling_data_semiannual+rolling_data_annual, axis=1, join='inner')
total_range = list(range(len(rolling_data_monthly)+len(rolling_data_semiannual)+len(rolling_data_annual)))
index_exclude = [len(rolling_data_monthly)-1,len(rolling_data_monthly)+len(rolling_data_semiannual)-1, len(total_range)-1]
month_spread = [1]*(len(rolling_data_monthly)-1)+[6]*(len(rolling_data_semiannual)-1)+[12]*(len(rolling_data_annual)-1)
yield_raw = [(merged_data['close_price'].ix[:, x]-merged_data['close_price'].ix[:, x+1]) /
merged_data['close_price'].ix[:, x+1] for x in total_range if x not in index_exclude]
yield_merged = pd.concat(yield_raw, axis=1)
yield_data = 100*yield_merged.values
change5_raw = [(merged_data['change5'].ix[:, x]-merged_data['change5'].ix[:, x+1]) for x in total_range
if x not in index_exclude]
change5_merged = pd.concat(change5_raw, axis=1)
change5_data = change5_merged.values
change10_raw = [(merged_data['change10'].ix[:, x]-merged_data['change10'].ix[:, x+1]) for x in total_range
if x not in index_exclude]
change10_merged = pd.concat(change10_raw, axis=1)
change10_data = change10_merged.values
change20_raw = [(merged_data['change20'].ix[:, x]-merged_data['change20'].ix[:, x+1]) for x in total_range
if x not in index_exclude]
change20_merged = pd.concat(change20_raw, axis=1)
change20_data = change20_merged.values
tr_dte_raw = [merged_data['tr_dte'].ix[:, x] for x in total_range if x not in index_exclude]
tr_dte_merged = pd.concat(tr_dte_raw, axis=1)
tr_dte_data = tr_dte_merged.values
ticker_month_raw = [merged_data['ticker_month'].ix[:, x] for x in total_range if x not in index_exclude]
ticker_month_merged = pd.concat(ticker_month_raw, axis=1)
ticker_month_data = ticker_month_merged.values
ticker1_list = [merged_data['ticker'].ix[-1, x] for x in total_range if x not in index_exclude]
ticker2_list = [merged_data['ticker'].ix[-1, x+1] for x in total_range if x not in index_exclude]
price_list = [(merged_data['close_price'].ix[-1, x]-merged_data['close_price'].ix[-1, x+1]) for x in total_range
if x not in index_exclude]
pca_out = stats.get_pca(data_input=yield_data, n_components=2)
residuals = yield_data-pca_out['model_fit']
pca_results = pd.DataFrame.from_items([('ticker1',ticker1_list),
('ticker2',ticker2_list),
('monthSpread',month_spread),
('tr_dte_front', tr_dte_data[-1]),
('ticker_month_front', ticker_month_data[-1]),
('residuals',residuals[-1]),
('price',price_list),
('yield',yield_data[-1]),
('z', (residuals[-1]-residuals.mean(axis=0))/residuals.std(axis=0)),
('factor_load1',pca_out['loadings'][0]),
('factor_load2',pca_out['loadings'][1]),
('change5', change5_data[-1]),
('change10', change10_data[-1]),
('change20', change20_data[-1])])
# notice that this date_to needs to me removed once we are done with backtesting
seasonality_adjustment = fs.get_pca_seasonality_adjustments(ticker_head=ticker_head,date_to=date_to)
pca_results = pd.merge(pca_results, seasonality_adjustment,how='left',on=['monthSpread','ticker_month_front'])
pca_results['z2'] = pca_results['z']-pca_results['z_seasonal_mean']
pca_results['residuals'] = pca_results['residuals'].round(3)
pca_results['yield'] = pca_results['yield'].round(2)
pca_results['z'] = pca_results['z'].round(2)
pca_results['z2'] = pca_results['z2'].round(2)
pca_results['z_seasonal_mean'] = pca_results['z_seasonal_mean'].round(2)
pca_results['factor_load1'] = pca_results['factor_load1'].round(3)
pca_results['factor_load2'] = pca_results['factor_load2'].round(3)
pca_results.to_pickle(output_dir + '/' + ticker_head + '.pkl')
return {'pca_results': pca_results, 'success': True}
