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_rolling_futures_price(**kwargs): if 'roll_tr_dte_aim' in kwargs.keys(): roll_tr_dte_aim = kwargs['roll_tr_dte_aim'] else: roll_tr_dte_aim = 50 futures_dataframe = gfp.get_futures_price_preloaded(**kwargs) futures_dataframe = futures_dataframe[futures_dataframe['cal_dte'] < 270] futures_dataframe.sort_values(['cont_indx', 'settle_date'], ascending=[True, True], inplace=True) grouped = futures_dataframe.groupby('cont_indx') shifted = grouped.shift(1) futures_dataframe['log_return'] = np.log(futures_dataframe['close_price'] / shifted['close_price']) futures_dataframe['tr_dte_diff'] = abs(roll_tr_dte_aim - futures_dataframe['tr_dte']) futures_dataframe.sort_values(['settle_date', 'tr_dte_diff'], ascending=[True, True], inplace=True) futures_dataframe.drop_duplicates('settle_date', inplace=True, keep='first') return futures_dataframe
def get_backtest_summary(**kwargs): futures_data_dictionary = { x: gfp.get_futures_price_preloaded(ticker_head=x) for x in cmi.futures_butterfly_strategy_tickerhead_list } date_list = kwargs['date_list'] if 'use_existing_filesQ' in kwargs.keys(): use_existing_filesQ = kwargs['use_existing_filesQ'] else: use_existing_filesQ = True backtest_output = [] for report_date in date_list: backtest_output.append( get_backtest_summary_4_date( report_date=report_date, futures_data_dictionary=futures_data_dictionary, use_existing_filesQ=use_existing_filesQ)) return { 'big_data': pd.concat(backtest_output), 'backtest_output': backtest_output }
def calc_realized_vol_4options_ticker(**kwargs): ticker = kwargs['ticker'] contract_specs_output = cmi.get_contract_specs(ticker) if contract_specs_output['ticker_class'] in ['Index', 'FX', 'Metal']: use_proxy_contract = True else: use_proxy_contract = False if use_proxy_contract: if 'futures_data_dictionary' in kwargs.keys(): futures_data_input = { 'ticker_head': contract_specs_output['ticker_head'], 'settle_date': kwargs['settle_date'] } futures_data_input['futures_data_dictionary'] = kwargs[ 'futures_data_dictionary'] data_out = gfp.get_futures_price_preloaded(**futures_data_input) data_out = data_out.reset_index() kwargs['ticker'] = data_out['ticker'].loc[ data_out['volume'].idxmax()] else: kwargs['ticker'] = omu.get_option_underlying(**kwargs) return calc_realized_vol_4futures_ticker(**kwargs)
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 backtest_spread_carry(**kwargs): date_list = kwargs['date_list'] risk = 1000 futures_data_dictionary = {x: gfp.get_futures_price_preloaded(ticker_head=x) for x in sc.max_tr_dte_limits.keys()} ticker_head_list = list(sc.max_tr_dte_limits.keys()) total_pnl_frame = pd.DataFrame({'report_date': date_list}) total_pnl_frame['portfolio'] = 0 backtest_output = [] for i in range(len(ticker_head_list)): total_pnl_frame[ticker_head_list[i]] = 0 for i in range(len(date_list)): spread_carry_output = sc.generate_spread_carry_sheet_4date(report_date=date_list[i],futures_data_dictionary=futures_data_dictionary) if spread_carry_output['success']: daily_sheet = spread_carry_output['spread_report'] else: continue backtest_output.append(daily_sheet) daily_sheet['q_carry_abs'] = abs(daily_sheet['q_carry']) pnl_tickerhead_frame = pd.DataFrame({'ticker_head': ticker_head_list}) pnl_tickerhead_frame['total_pnl'] = 0 for j in range(len(ticker_head_list)): ticker_head_results = daily_sheet[daily_sheet['tickerHead'] == ticker_head_list[j]] if len(ticker_head_results.index)<=1: continue max_q_carry_abs = ticker_head_results['q_carry_abs'].max() if np.isnan(max_q_carry_abs): continue selected_spread = ticker_head_results.ix[ticker_head_results['q_carry_abs'].idxmax()] if selected_spread['q_carry']>0: total_pnl_frame[ticker_head_list[j]][i] = selected_spread['change5']*risk/abs(selected_spread['downside']) pnl_tickerhead_frame['total_pnl'][j] = total_pnl_frame[ticker_head_list[j]][i] elif selected_spread['q_carry']<0: total_pnl_frame[ticker_head_list[j]][i] = -selected_spread['change5']*risk/abs(selected_spread['upside']) pnl_tickerhead_frame['total_pnl'][j] = total_pnl_frame[ticker_head_list[j]][i] total_pnl_frame['portfolio'][i] = pnl_tickerhead_frame['total_pnl'].sum() big_data = pd.concat(backtest_output) big_data['pnl_long5'] = big_data['change5']*risk/abs(big_data['downside']) big_data['pnl_short5'] = -big_data['change5']*risk/abs(big_data['upside']) big_data['pnl_final'] = big_data['pnl_long5'] big_data.loc[big_data['q_carry'] < 0, 'pnl_final'] = big_data.loc[big_data['q_carry'] <0, 'pnl_short5'] return {'total_pnl_frame': total_pnl_frame, 'big_data': big_data}
def construct_spread_portfolio(**kwargs): date_list = kwargs['date_list'] risk = 1000 futures_data_dictionary = {x: gfp.get_futures_price_preloaded(ticker_head=x) for x in sc.max_tr_dte_limits.keys()} ticker_head_list = list(sc.max_tr_dte_limits.keys()) total_pnl_frame = pd.DataFrame({'report_date': date_list}) total_pnl_frame['portfolio'] = 0 for i in range(len(ticker_head_list)): total_pnl_frame[ticker_head_list[i]] = 0 for i in range(len(date_list)): spread_carry_output = sc.generate_spread_carry_sheet_4date(report_date=date_list[i],futures_data_dictionary=futures_data_dictionary) if spread_carry_output['success']: daily_sheet = spread_carry_output['spread_report'] else: continue pnl_tickerhead_frame = pd.DataFrame({'ticker_head': ticker_head_list}) pnl_tickerhead_frame['buy_mean_pnl'] = 0 pnl_tickerhead_frame['sell_mean_pnl'] = 0 pnl_tickerhead_frame['total_pnl'] = 0 daily_sheet = \ daily_sheet[(np.isfinite(daily_sheet['change5']))& (np.isfinite(daily_sheet['upside']))& (np.isfinite(daily_sheet['downside']))] for j in range(len(ticker_head_list)): ticker_head_results = daily_sheet[daily_sheet['tickerHead'] == ticker_head_list[j]] filter_output_long = sf.get_spread_carry_filters(data_frame_input=ticker_head_results, filter_list=['long1']) filter_output_short = sf.get_spread_carry_filters(data_frame_input=ticker_head_results, filter_list=['short1']) selected_short_trades = ticker_head_results[filter_output_short['selection_indx']] selected_long_trades = ticker_head_results[filter_output_long['selection_indx']] if len(selected_short_trades.index) > 0: short_pnl = -selected_short_trades['change5']*risk/abs(selected_short_trades['upside']) pnl_tickerhead_frame['sell_mean_pnl'][j] = short_pnl.mean() if len(selected_long_trades.index) > 0: long_pnl = selected_long_trades['change5']*risk/abs(selected_long_trades['downside']) pnl_tickerhead_frame['buy_mean_pnl'][j] = long_pnl.mean() pnl_tickerhead_frame['total_pnl'][j] = pnl_tickerhead_frame['buy_mean_pnl'][j] + pnl_tickerhead_frame['sell_mean_pnl'][j] total_pnl_frame[ticker_head_list[j]][i] = pnl_tickerhead_frame['total_pnl'][j] total_pnl_frame['portfolio'][i] = pnl_tickerhead_frame['total_pnl'].sum() return total_pnl_frame
def get_spread_carry_4tickerhead(**kwargs): ticker_head = kwargs['ticker_head'] report_date = kwargs['report_date'] if 'min_tr_dte' in kwargs.keys(): min_tr_dte = kwargs['min_tr_dte'] else: min_tr_dte = 15 if 'futures_data_dictionary' in kwargs.keys(): futures_data_dictionary = kwargs['futures_data_dictionary'] else: futures_data_dictionary = { ticker_head: gfp.get_futures_price_preloaded(ticker_head=ticker_head) } if 'datetime5_years_ago' in kwargs.keys(): datetime5_years_ago = kwargs['datetime5_years_ago'] else: date5_years_ago = cu.doubledate_shift(report_date, 5 * 365) datetime5_years_ago = cu.convert_doubledate_2datetime(date5_years_ago) daily_data = gfp.get_futures_price_preloaded( ticker_head=ticker_head, settle_date=report_date, futures_data_dictionary=futures_data_dictionary) daily_data = daily_data[(daily_data['tr_dte'] >= min_tr_dte) & ( daily_data['tr_dte'] <= max_tr_dte_limits[ticker_head])] if len(daily_data.index) > 1: carry_signals = fs.get_futures_spread_carry_signals( ticker_list=daily_data['ticker'].values, tr_dte_list=daily_data['tr_dte'].values, futures_data_dictionary=futures_data_dictionary, datetime5_years_ago=datetime5_years_ago, date_to=report_date) return {'success': True, 'carry_signals': carry_signals} else: return {'success': False, 'carry_signals': pd.DataFrame()}
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_contract_summary_stats(**kwargs): ticker = kwargs['ticker'] date_to = kwargs['date_to'] data_out = gfp.get_futures_price_preloaded(ticker=ticker) datetime_to = cu.convert_doubledate_2datetime(date_to) data_out = data_out[data_out['settle_date'] <= datetime_to] data_out['close_price_daily_diff'] = data_out['close_price'] - data_out['close_price'].shift(1) daily_noise = np.std(data_out['close_price_daily_diff'].iloc[-60:]) average_volume = np.mean(data_out['volume'].iloc[-20:]) return {'daily_noise': daily_noise, 'average_volume':average_volume}
def get_arma_signals(**kwargs): ticker_head = kwargs['ticker_head'] date_to = kwargs['date_to'] date2_years_ago = cu.doubledate_shift(date_to, 2*365) panel_data = gfp.get_futures_price_preloaded(ticker_head=ticker_head,settle_date_from=date2_years_ago,settle_date_to=date_to) panel_data = panel_data[panel_data['tr_dte']>=40] panel_data.sort(['settle_date','tr_dte'],ascending=[True,True],inplace=True) rolling_data = panel_data.drop_duplicates(subset=['settle_date'], take_last=False) rolling_data['percent_change'] = 100*rolling_data['change_1']/rolling_data['close_price'] rolling_data = rolling_data[rolling_data['percent_change'].notnull()] data_input = np.array(rolling_data['percent_change']) daily_noise = np.std(data_input) param1_list = [] param2_list = [] akaike_list = [] forecast_list = [] for i in range(0, 3): for j in range(0, 3): try: model_output = sm.tsa.ARMA(data_input, (i,j)).fit() except: continue param1_list.append(i) param2_list.append(j) akaike_list.append(model_output.aic) forecast_list.append(model_output.predict(len(data_input),len(data_input))[0]) result_frame = pd.DataFrame.from_items([('param1', param1_list), ('param2', param2_list), ('akaike', akaike_list), ('forecast', forecast_list)]) result_frame.sort('akaike',ascending=True,inplace=True) param1 = result_frame['param1'].iloc[0] param2 = result_frame['param2'].iloc[0] if (param1 == 0)&(param2 == 0): forecast = np.nan else: forecast = result_frame['forecast'].iloc[0] return {'success': True, 'forecast':forecast,'normalized_forecast': forecast/daily_noise, 'param1':param1,'param2':param2, 'normalized_target': 100*(rolling_data['change1_instant'].iloc[-1]/rolling_data['close_price'].iloc[-1])/daily_noise}
def generate_underlying_proxy_report(**kwargs): con = msu.get_my_sql_connection(**kwargs) report_date = kwargs['report_date'] futures_dataframe = cl.generate_futures_list_dataframe(date_to=report_date) futures_flat_curve = futures_dataframe[ futures_dataframe['ticker_class'].isin( ['FX', 'Metal', 'Treasury', 'Index'])] futures_flat_curve.reset_index(drop=True, inplace=True) futures_flat_curve['tr_days_2roll'] = futures_flat_curve.apply( lambda x: exp.get_days2_roll(ticker=x['ticker'], instrument='Futures', date_to=report_date, con=con)['tr_days_2roll'], axis=1) futures_data_dictionary = { x: gfp.get_futures_price_preloaded(ticker_head=x) for x in futures_flat_curve['ticker_head'].unique() } proxy_output_list = [ get_underlying_proxy_ticker( ticker=futures_flat_curve['ticker'].iloc[x], settle_date=report_date, con=con, futures_data_dictionary=futures_data_dictionary) for x in range(len(futures_flat_curve.index)) ] futures_flat_curve['proxy_ticker'] = [ x['ticker'] for x in proxy_output_list ] futures_flat_curve['add_2_proxy'] = [ x['add_2_proxy'] for x in proxy_output_list ] ta_output_dir = dn.get_dated_directory_extension(folder_date=report_date, ext='ta') writer = pd.ExcelWriter(ta_output_dir + '/proxy_report.xlsx', engine='xlsxwriter') futures_flat_curve = futures_flat_curve[[ 'ticker', 'ticker_head', 'ticker_class', 'volume', 'tr_days_2roll', 'proxy_ticker', 'add_2_proxy' ]] futures_flat_curve.to_excel(writer, sheet_name='proxy_report') writer.save() if 'con' not in kwargs.keys(): con.close()
def cal_greeks_4option_maturity(**kwargs): option_prices = gop.get_options_price_from_db(**kwargs) if option_prices.empty: return pd.DataFrame() option_prices = option_prices[option_prices['strike'] > 0] option_prices.reset_index(drop=True, inplace=True) contract_specs_out = cmi.get_contract_specs(kwargs['ticker']) exercise_type = cmi.get_option_exercise_type(**contract_specs_out) underlying_ticker = oput.get_option_underlying(**kwargs) futures_price_output = gfp.get_futures_price_preloaded( ticker=underlying_ticker, settle_date=kwargs['settle_date']) if futures_price_output.empty: return pd.DataFrame() underlying_price = futures_price_output['close_price'].iloc[0] expiration_datetime = exp.get_expiration_from_db(instrument='options', **kwargs) expiration_date = int(expiration_datetime.strftime('%Y%m%d')) interest_rate = grfs.get_simple_rate( as_of_date=kwargs['settle_date'], date_to=expiration_date)['rate_output'] option_greeks = [ qom.get_option_greeks(underlying=underlying_price, option_price=float( option_prices['close_price'].iloc[x]), strike=float(option_prices['strike'].iloc[x]), risk_free_rate=interest_rate, expiration_date=expiration_date, calculation_date=kwargs['settle_date'], option_type=option_prices['option_type'].iloc[x], exercise_type=exercise_type) for x in range(len(option_prices.index)) ] greek_frame = pd.DataFrame(option_greeks) return pd.concat([ greek_frame[['delta', 'gamma', 'implied_vol', 'theta', 'vega']], option_prices ], axis=1)
def get_spread_carry_4tickerhead(**kwargs): ticker_head = kwargs['ticker_head'] report_date = kwargs['report_date'] if 'min_tr_dte' in kwargs.keys(): min_tr_dte = kwargs['min_tr_dte'] else: min_tr_dte = 10 if 'futures_data_dictionary' in kwargs.keys(): futures_data_dictionary = kwargs['futures_data_dictionary'] else: futures_data_dictionary = {ticker_head: gfp.get_futures_price_preloaded(ticker_head=ticker_head)} if 'datetime5_years_ago' in kwargs.keys(): datetime5_years_ago = kwargs['datetime5_years_ago'] else: date5_years_ago = cu.doubledate_shift(report_date,5*365) datetime5_years_ago = cu.convert_doubledate_2datetime(date5_years_ago) daily_data = gfp.get_futures_price_preloaded(ticker_head=ticker_head, settle_date=report_date, futures_data_dictionary=futures_data_dictionary) daily_data = daily_data[(daily_data['tr_dte'] >= min_tr_dte) & (daily_data['tr_dte'] <= max_tr_dte_limits[ticker_head])] if len(daily_data.index) > 1: carry_signals = fs.get_futures_spread_carry_signals(ticker_list=daily_data['ticker'].values, tr_dte_list=daily_data['tr_dte'].values, futures_data_dictionary=futures_data_dictionary, datetime5_years_ago=datetime5_years_ago, date_to=report_date) return {'success': True, 'carry_signals': carry_signals} else: return {'success': False, 'carry_signals': pd.DataFrame()}
def calc_intrday_pnl_from_prices(**kwargs): if 'as_of_date' in kwargs.keys(): as_of_date = kwargs['as_of_date'] else: as_of_date = exp.doubledate_shift_bus_days() net_position_frame = tas.get_net_position_4strategy_alias(alias=kwargs['alias'], as_of_date=as_of_date) net_position_frame['ticker_head'] = [cmi.get_contract_specs(x)['ticker_head'] for x in net_position_frame['ticker']] net_position_frame['contract_multiplier'] = [cmi.contract_multiplier[x] for x in net_position_frame['ticker_head']] con = msu.get_my_sql_connection(**kwargs) option_frame = net_position_frame[net_position_frame['instrument'] == 'O'] #option_frame = option_frame[(option_frame['strike_price'] == 54)|(option_frame['strike_price'] == 60)] #option_frame = option_frame[option_frame['strike_price'] == 112] #option_frame['qty'].loc[option_frame['ticker']=='LNV2016'] = -20 option_frame['close_price'] = [gop.get_options_price_from_db(ticker=option_frame['ticker'].iloc[x], strike=option_frame['strike_price'].iloc[x], option_type=option_frame['option_type'].iloc[x], con=con,settle_date=as_of_date)['close_price'][0] for x in range(len(option_frame.index))] structure_quantity = abs(option_frame['qty']).unique()[0] structure_multiplier = option_frame['contract_multiplier'].unique()[0] structure_price = sum(option_frame['close_price']*option_frame['qty'])/structure_quantity if structure_price<0: structure_quantity = -structure_quantity structure_price = -structure_price structure_pnl = structure_quantity*structure_multiplier*(kwargs['structure_price']-structure_price) futures_frame = net_position_frame[net_position_frame['instrument'] == 'F'] futures_frame['close_price'] = [gfp.get_futures_price_preloaded(ticker=x, settle_date=as_of_date)['close_price'].iloc[0] for x in futures_frame['ticker']] futures_frame['intraday_price'] = [kwargs[x] for x in futures_frame['ticker']] futures_frame['intraday_pnl'] = (futures_frame['intraday_price']-futures_frame['close_price'])*futures_frame['qty']*futures_frame['contract_multiplier'] if 'con' not in kwargs.keys(): con.close() return {'structure_pnl': structure_pnl, 'futures_pnl': futures_frame['intraday_pnl'].sum(),'structure_settle': structure_price}
def calc_realized_vol_4futures_ticker(**kwargs): settle_date = kwargs.pop('settle_date') num_obs = kwargs.pop('num_obs', 20) futures_price_output = gfp.get_futures_price_preloaded(**kwargs) settle_datetime = cu.convert_doubledate_2datetime(settle_date) futures_price_selected = futures_price_output[futures_price_output['settle_date'] <= settle_datetime] logreturns = np.log(futures_price_selected['close_price'][-(num_obs+1):]/ futures_price_selected['close_price'][-(num_obs+1):].shift(1)) return 100*np.sqrt(252*np.mean(np.square(logreturns)))
def calc_intraday_structure_pnl_from_prices(**kwargs): if 'as_of_date' in kwargs.keys(): as_of_date = kwargs['as_of_date'] else: as_of_date = exp.doubledate_shift_bus_days() con = msu.get_my_sql_connection(**kwargs) structure_type = kwargs['structure_type'] structure_price = kwargs['structure_price'] ticker_list = kwargs['ticker_list'] strike_list = kwargs['strike_list'] underlying_price_list = kwargs['underlying_price_list'] qty = kwargs['qty'] if structure_type == 'straddle_spread': option_frame = pd.DataFrame.from_items([('ticker', [ticker_list[0], ticker_list[0], ticker_list[1], ticker_list[1]]), ('option_type', ['C', 'P', 'C', 'P']), ('strike_price', [strike_list[0], strike_list[0], strike_list[1],strike_list[1]]), ('qty', [-1, -1, 1, 1])]) option_price_output = [gop.get_options_price_from_db(ticker=option_frame['ticker'].iloc[x], strike=option_frame['strike_price'].iloc[x], option_type=option_frame['option_type'].iloc[x], con=con,settle_date=as_of_date,column_names=['close_price','delta']) for x in range(len(option_frame.index))] option_frame['delta'] = [option_price_output[x]['delta'][0] for x in range(len(option_frame.index))] option_frame['close_price'] = [option_price_output[x]['close_price'][0] for x in range(len(option_frame.index))] option_frame['PQ'] = option_frame['close_price']*option_frame['qty'] option_frame['signed_delta'] = option_frame['delta']*option_frame['qty'] delta_list = [option_frame[option_frame['ticker'] == x]['signed_delta'].sum() for x in ticker_list] ticker_head = cmi.get_contract_specs(ticker_list[0])['ticker_head'] contract_multiplier = cmi.contract_multiplier[ticker_head] structure_price_yesterday = option_frame['PQ'].sum() structure_pnl = qty*(structure_price-structure_price_yesterday)*contract_multiplier underlying_ticker_list = [oputil.get_option_underlying(ticker=x) for x in ticker_list] underlying_price_list_yesterday = [gfp.get_futures_price_preloaded(ticker=x, settle_date=as_of_date)['close_price'].iloc[0] for x in underlying_ticker_list] delta_pnl = contract_multiplier*sum([-delta_list[x]*qty*(underlying_price_list[x]-underlying_price_list_yesterday[x]) for x in range(len(delta_list))]) return {'total_pnl': structure_pnl+delta_pnl, 'structure_pnl': structure_pnl, 'delta_pnl': delta_pnl, 'structure_price_yesterday': structure_price_yesterday }
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 get_rolling_curve_data(**kwargs): ticker_head = kwargs['ticker_head'] num_contracts = kwargs['num_contracts'] front_tr_dte_limit = kwargs['front_tr_dte_limit'] date_from = kwargs['date_from'] date_to = kwargs['date_to'] date_from_datetime = cu.convert_doubledate_2datetime(date_from) date_to_datetime = cu.convert_doubledate_2datetime(date_to) panel_data = gfp.get_futures_price_preloaded(ticker_head=ticker_head) panel_data = panel_data.loc[(panel_data['settle_date'] >= date_from_datetime) & (panel_data['settle_date'] <= date_to_datetime) & (panel_data['tr_dte'] >= front_tr_dte_limit)] if 'month_separation' in kwargs.keys(): month_separation = kwargs['month_separation'] elif ticker_head == 'ED': month_separation = 3 else: month_separation = 1 if month_separation != 1: panel_data = panel_data[panel_data['ticker_month'] % month_separation == 0] panel_data = panel_data[np.isfinite(panel_data['close_price'])] sorted_data = panel_data.sort_values(['settle_date', 'tr_dte'], ascending=[True, True]) filtered_data = sorted_data.groupby('settle_date').filter(lambda x:len(x)>=num_contracts) filtered_data2 = filtered_data.groupby('settle_date').filter(lambda x: all([cmi.get_month_seperation_from_cont_indx(x['cont_indx'].values[i], x['cont_indx'].values[i+1]) ==- month_separation for i in range(num_contracts-1)])) grouped = filtered_data2.groupby('settle_date') rolling_data_list = [] for i in range(num_contracts): rolling_data_list.append(grouped.nth(i)) return rolling_data_list
def get_rolling_curve_data(**kwargs): ticker_head = kwargs['ticker_head'] num_contracts = kwargs['num_contracts'] front_tr_dte_limit = kwargs['front_tr_dte_limit'] date_from = kwargs['date_from'] date_to = kwargs['date_to'] date_from_datetime = cu.convert_doubledate_2datetime(date_from) date_to_datetime = cu.convert_doubledate_2datetime(date_to) panel_data = gfp.get_futures_price_preloaded(ticker_head=ticker_head) panel_data = panel_data.loc[(panel_data['settle_date'] >= date_from_datetime) & (panel_data['settle_date'] <= date_to_datetime) & (panel_data['tr_dte'] >= front_tr_dte_limit)] if 'month_separation' in kwargs.keys(): month_separation = kwargs['month_separation'] elif ticker_head == 'ED': month_separation = 3 else: month_separation = 1 if month_separation != 1: panel_data = panel_data[panel_data['ticker_month'] % month_separation == 0] panel_data = panel_data[np.isfinite(panel_data['close_price'])] sorted_data = panel_data.sort(['settle_date', 'tr_dte'], ascending=[True, True]) filtered_data = sorted_data.groupby('settle_date').filter(lambda x:len(x)>=num_contracts) filtered_data2 = filtered_data.groupby('settle_date').filter(lambda x: all([cmi.get_month_seperation_from_cont_indx(x['cont_indx'].values[i], x['cont_indx'].values[i+1]) ==- month_separation for i in range(num_contracts-1)])) grouped = filtered_data2.groupby('settle_date') rolling_data_list = [] for i in range(num_contracts): rolling_data_list.append(grouped.nth(i)) return rolling_data_list
def get_results_4ticker(**kwargs): ticker = kwargs['ticker'] date_to = kwargs['date_to'] candle_frame = qd.get_continuous_bar_data(ticker=ticker, date_to=date_to, num_days_back=0) history_frame = gfp.get_futures_price_preloaded(ticker=ticker, settle_date_to=date_to) history_frame = history_frame.iloc[:-1] history_frame['ma9'] = history_frame['close_price'].rolling(window=9, center=False).mean() high_1 = history_frame['high_price'].iloc[-1] low_1 = history_frame['low_price'].iloc[-1] trend_direction = 0 if history_frame['ma9'].iloc[-1] > history_frame['ma9'].iloc[-2]: trend_direction = 1 elif history_frame['ma9'].iloc[-1] < history_frame['ma9'].iloc[-2]: trend_direction = -1
def get_futures_curve_chart_4date(**kwargs): ticker_head = kwargs['ticker_head'] settle_date = kwargs['settle_date'] data2_plot = gfp.get_futures_price_preloaded(ticker_head=ticker_head, settle_date=settle_date) if 'tr_dte_limit' in kwargs.keys(): data2_plot = data2_plot[data2_plot['tr_dte'] <= kwargs['tr_dte_limit']] ticker_year_short = data2_plot['ticker_year'] % 10 month_letters = [cmi.letter_month_string[x-1] for x in data2_plot['ticker_month'].values] tick_labels = [month_letters[x]+str(ticker_year_short.values[x]) for x in range(len(month_letters))] plt.figure(figsize=(16, 7)) plt.plot(data2_plot['close_price']) plt.xticks(range(len(data2_plot.index)),tick_labels) plt.grid() plt.show()
def get_futures_curve_chart_4date(**kwargs): ticker_head = kwargs['ticker_head'] settle_date = kwargs['settle_date'] data2_plot = gfp.get_futures_price_preloaded(ticker_head=ticker_head, settle_date=settle_date) if 'tr_dte_limit' in kwargs.keys(): data2_plot = data2_plot[data2_plot['tr_dte'] <= kwargs['tr_dte_limit']] ticker_year_short = data2_plot['ticker_year'] % 10 month_letters = [cmi.letter_month_string[x-1] for x in data2_plot['ticker_month'].values] tick_labels = [month_letters[x]+str(ticker_year_short.values[x]) for x in range(len(month_letters))] plt.figure(figsize=(16, 7)) plt.plot(range(len(data2_plot.index)),data2_plot['close_price']) plt.xticks(range(len(data2_plot.index)),tick_labels) plt.grid() plt.show()
def save_ib_data(**kwargs): if 'duration_str' in kwargs.keys(): duration_str = kwargs['duration_str'] else: duration_str = '2 M' 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 = cmi.cme_futures_tickerhead_list 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 = ticker_frame[~((ticker_frame['ticker_head'] == 'ED') & (ticker_frame['tr_dte'] < 250))] ticker_frame = ticker_frame[~((ticker_frame['ticker_head'] == 'GC') | (ticker_frame['ticker_head'] == 'SI'))] ticker_frame.sort_values(['ticker_head', 'volume'], ascending=[True, False], inplace=True) ticker_frame.drop_duplicates(subset=['ticker_head'], keep='first', inplace=True) app.ticker_list = list(ticker_frame['ticker']) app.output_dir = sd.get_directory_name(ext='ib_data') app.durationStr = duration_str app.con = con app.connect(client_id=5) app.run()
def get_rolling_futures_price(**kwargs): if 'roll_tr_dte_aim' in kwargs.keys(): roll_tr_dte_aim = kwargs['roll_tr_dte_aim'] else: roll_tr_dte_aim = 50 futures_dataframe = gfp.get_futures_price_preloaded(**kwargs) futures_dataframe = futures_dataframe[futures_dataframe['cal_dte'] < 270] futures_dataframe.sort(['cont_indx', 'settle_date'], ascending=[True,True], inplace=True) grouped = futures_dataframe.groupby('cont_indx') shifted = grouped.shift(1) futures_dataframe['log_return'] = np.log(futures_dataframe['close_price']/shifted['close_price']) futures_dataframe['tr_dte_diff'] = abs(roll_tr_dte_aim-futures_dataframe['tr_dte']) futures_dataframe.sort(['settle_date','tr_dte_diff'], ascending=[True,True], inplace=True) futures_dataframe.drop_duplicates('settle_date', inplace=True, take_last=False) return futures_dataframe
def calculate_contract_risk(**kwargs): contract_frame = kwargs['contract_frame'] current_date = kwargs['current_date'] contract_frame['risk'] = np.nan contract_frame['contract_multiplier'] = np.nan for i in range(len(contract_frame.index)): ticker_raw = contract_frame['ticker'].iloc[i] ticker_output = ticker_raw.split('-') contract_multiplier = cmi.contract_multiplier[ contract_frame['ticker_head'].iloc[i]] contract_frame['contract_multiplier'].iloc[i] = contract_multiplier if len(ticker_output) == 1: ticker = ticker_output[0] data_out = gfp.get_futures_price_preloaded( ticker=ticker, settle_date_to=current_date) recent_data = data_out.iloc[-10:] contract_frame['risk'].iloc[i] = contract_multiplier * ( recent_data['close_price'].max() - recent_data['close_price'].min()) if len(ticker_output) > 1: aligned_output = opUtil.get_aligned_futures_data( contract_list=ticker_output, contracts_back=1, aggregation_method=12, date_to=current_date) aligned_data = aligned_output['aligned_data'] recent_data = aligned_data.iloc[-10:] spread_price = recent_data['c1']['close_price'] - recent_data[ 'c2']['close_price'] contract_frame['risk'].iloc[i] = contract_multiplier * ( spread_price.max() - spread_price.min()) return contract_frame
def calc_realized_vol_4options_ticker(**kwargs): ticker = kwargs['ticker'] contract_specs_output = cmi.get_contract_specs(ticker) if contract_specs_output['ticker_class'] in ['Index', 'FX', 'Metal']: use_proxy_contract = True else: use_proxy_contract = False if use_proxy_contract: if 'futures_data_dictionary' in kwargs.keys(): futures_data_input = {'ticker_head': contract_specs_output['ticker_head'],'settle_date': kwargs['settle_date']} futures_data_input['futures_data_dictionary'] = kwargs['futures_data_dictionary'] data_out = gfp.get_futures_price_preloaded(**futures_data_input) data_out = data_out.reset_index() kwargs['ticker'] = data_out['ticker'].loc[data_out['volume'].idxmax()] else: kwargs['ticker'] = omu.get_option_underlying(**kwargs) return calc_realized_vol_4futures_ticker(**kwargs)
def cal_greeks_4option_maturity(**kwargs): option_prices = gop.get_options_price_from_db(**kwargs) if option_prices.empty: return pd.DataFrame() contract_specs_out = cmi.get_contract_specs(kwargs['ticker']) exercise_type = cmi.get_option_exercise_type(**contract_specs_out) underlying_ticker = oput.get_option_underlying(**kwargs) futures_price_output = gfp.get_futures_price_preloaded(ticker=underlying_ticker, settle_date=kwargs['settle_date']) if futures_price_output.empty: return pd.DataFrame() underlying_price = futures_price_output['close_price'].iloc[0] expiration_datetime = exp.get_expiration_from_db(instrument='options', **kwargs) expiration_date = int(expiration_datetime.strftime('%Y%m%d')) interest_rate = grfs.get_simple_rate(as_of_date=kwargs['settle_date'], date_to=expiration_date)['rate_output'] #print(kwargs['settle_date']) #print(expiration_date) option_greeks = [qom.get_option_greeks(underlying=underlying_price, option_price=float(option_prices['close_price'].iloc[x]), strike=float(option_prices['strike'].iloc[x]), risk_free_rate=interest_rate, expiration_date=expiration_date, calculation_date=kwargs['settle_date'], option_type=option_prices['option_type'].iloc[x], exercise_type=exercise_type) for x in range(len(option_prices.index))] greek_frame = pd.DataFrame(option_greeks) return pd.concat([greek_frame[['delta', 'gamma', 'implied_vol', 'theta', 'vega']], option_prices], axis=1)
def get_cot_strategy_signals(**kwargs): ticker_head = kwargs['ticker_head'] date_to = kwargs['date_to'] datetime_to = cu.convert_doubledate_2datetime(date_to) data_out = gfp.get_futures_price_preloaded(ticker_head=ticker_head) data_out = data_out[data_out['settle_date'] <= datetime_to] data_out_front = data_out[data_out['tr_dte'] <= 60] data_out_front.drop_duplicates(subset=['settle_date'], keep='last', inplace=True) data_out_back = data_out[data_out['tr_dte'] > 60] data_out_back.drop_duplicates(subset=['settle_date'], keep='last', inplace=True) merged_data = pd.merge(data_out_front[['settle_date','tr_dte','close_price']],data_out_back[['tr_dte','close_price','settle_date','ticker','change_1']],how='inner',on='settle_date') merged_data['const_mat']=((merged_data['tr_dte_y']-60)*merged_data['close_price_x']+ (60-merged_data['tr_dte_x'])*merged_data['close_price_y'])/\ (merged_data['tr_dte_y']-merged_data['tr_dte_x']) cot_output = cot.get_cot_data(ticker_head=ticker_head,date_to=date_to) cot_output['comm_net'] = cot_output['Commercial Long']-cot_output['Commercial Short'] cot_output['spec_net'] = cot_output['Noncommercial Long'] - cot_output['Noncommercial Short'] cot_output['comm_min'] = cot_output['comm_net'].rolling(window=156, min_periods=156, center=False).min() cot_output['comm_max'] = cot_output['comm_net'].rolling(window=156, min_periods=156, center=False).max() cot_output['cot_index_slow'] = 100 * (cot_output['comm_net'] - cot_output['comm_min']) / ( cot_output['comm_max'] - cot_output['comm_min']) cot_output['settle_date'] = [x+dt.timedelta(days=3) for x in cot_output['settle_date']] combined_data = pd.merge(merged_data,cot_output,how='inner',on='settle_date') return {'ticker_head':ticker_head, 'success': True, 'cot_index_slow': cot_output['cot_index_slow'].iloc[-1], 'combined_data': combined_data,}
def get_tickers_4date(**kwargs): ticker_head_list = cmi.cme_futures_tickerhead_list data_list = [ gfp.get_futures_price_preloaded(ticker_head=x, settle_date=kwargs['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) ticker_frame.reset_index(drop=True, inplace=True) return ticker_frame[['ticker', 'ticker_head']]
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 get_backtest_summary(**kwargs): futures_data_dictionary = { x: gfp.get_futures_price_preloaded(ticker_head=x) for x in cmi.futures_butterfly_strategy_tickerhead_list } date_list = kwargs["date_list"] if "use_existing_filesQ" in kwargs.keys(): use_existing_filesQ = kwargs["use_existing_filesQ"] else: use_existing_filesQ = True backtest_output = [] for report_date in date_list: backtest_output.append( get_backtest_summary_4_date( report_date=report_date, futures_data_dictionary=futures_data_dictionary, use_existing_filesQ=use_existing_filesQ, ) ) return {"big_data": pd.concat(backtest_output), "backtest_output": backtest_output}
def get_futures_butterfly_signals(**kwargs): ticker_list = kwargs['ticker_list'] date_to = kwargs['date_to'] if 'tr_dte_list' in kwargs.keys(): tr_dte_list = kwargs['tr_dte_list'] else: tr_dte_list = [exp.get_futures_days2_expiration({'ticker': x,'date_to': date_to}) for x in ticker_list] if 'aggregation_method' in kwargs.keys() and 'contracts_back' in kwargs.keys(): aggregation_method = kwargs['aggregation_method'] contracts_back = kwargs['contracts_back'] else: amcb_output = opUtil.get_aggregation_method_contracts_back(cmi.get_contract_specs(ticker_list[0])) aggregation_method = amcb_output['aggregation_method'] contracts_back = amcb_output['contracts_back'] if 'use_last_as_current' in kwargs.keys(): use_last_as_current = kwargs['use_last_as_current'] else: use_last_as_current = False 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 [cmi.get_contract_specs(ticker_list[0])['ticker_head']]} if 'contract_multiplier' in kwargs.keys(): contract_multiplier = kwargs['contract_multiplier'] else: contract_multiplier = cmi.contract_multiplier[cmi.get_contract_specs(ticker_list[0])['ticker_head']] if 'datetime5_years_ago' in kwargs.keys(): datetime5_years_ago = kwargs['datetime5_years_ago'] else: date5_years_ago = cu.doubledate_shift(date_to,5*365) datetime5_years_ago = cu.convert_doubledate_2datetime(date5_years_ago) if 'datetime2_months_ago' in kwargs.keys(): datetime2_months_ago = kwargs['datetime2_months_ago'] else: date2_months_ago = cu.doubledate_shift(date_to,60) datetime2_months_ago = cu.convert_doubledate_2datetime(date2_months_ago) aligned_output = opUtil.get_aligned_futures_data(contract_list=ticker_list, tr_dte_list=tr_dte_list, aggregation_method=aggregation_method, contracts_back=contracts_back, date_to=date_to, futures_data_dictionary=futures_data_dictionary, use_last_as_current=use_last_as_current) current_data = aligned_output['current_data'] aligned_data = aligned_output['aligned_data'] month_diff_1 = 12*(current_data['c1']['ticker_year']-current_data['c2']['ticker_year'])+(current_data['c1']['ticker_month']-current_data['c2']['ticker_month']) month_diff_2 = 12*(current_data['c2']['ticker_year']-current_data['c3']['ticker_year'])+(current_data['c2']['ticker_month']-current_data['c3']['ticker_month']) weight_11 = 2*month_diff_2/(month_diff_1+month_diff_1) weight_12 = -2 weight_13 = 2*month_diff_1/(month_diff_1+month_diff_1) price_1 = current_data['c1']['close_price'] price_2 = current_data['c2']['close_price'] price_3 = current_data['c3']['close_price'] linear_interp_price2 = (weight_11*aligned_data['c1']['close_price']+weight_13*aligned_data['c3']['close_price'])/2 butterfly_price = aligned_data['c1']['close_price']-2*aligned_data['c2']['close_price']+aligned_data['c3']['close_price'] price_ratio = linear_interp_price2/aligned_data['c2']['close_price'] linear_interp_price2_current = (weight_11*price_1+weight_13*price_3)/2 price_ratio_current = linear_interp_price2_current/price_2 q = stats.get_quantile_from_number({'x': price_ratio_current, 'y': price_ratio.values, 'clean_num_obs': max(100, round(3*len(price_ratio.values)/4))}) qf = stats.get_quantile_from_number({'x': price_ratio_current, 'y': price_ratio.values[-40:], 'clean_num_obs': 30}) recent_quantile_list = [stats.get_quantile_from_number({'x': x, 'y': price_ratio.values[-40:], 'clean_num_obs': 30}) for x in price_ratio.values[-40:]] weight1 = weight_11 weight2 = weight_12 weight3 = weight_13 last5_years_indx = aligned_data['settle_date']>=datetime5_years_ago last2_months_indx = aligned_data['settle_date']>=datetime2_months_ago data_last5_years = aligned_data[last5_years_indx] yield1 = 100*(aligned_data['c1']['close_price']-aligned_data['c2']['close_price'])/aligned_data['c2']['close_price'] yield2 = 100*(aligned_data['c2']['close_price']-aligned_data['c3']['close_price'])/aligned_data['c3']['close_price'] yield1_last5_years = yield1[last5_years_indx] yield2_last5_years = yield2[last5_years_indx] yield1_current = 100*(current_data['c1']['close_price']-current_data['c2']['close_price'])/current_data['c2']['close_price'] yield2_current = 100*(current_data['c2']['close_price']-current_data['c3']['close_price'])/current_data['c3']['close_price'] butterfly_price_current = current_data['c1']['close_price']\ -2*current_data['c2']['close_price']\ +current_data['c3']['close_price'] yield_regress_output = stats.get_regression_results({'x':yield2, 'y':yield1,'x_current': yield2_current, 'y_current': yield1_current, 'clean_num_obs': max(100, round(3*len(yield1.values)/4))}) yield_regress_output_last5_years = stats.get_regression_results({'x':yield2_last5_years, 'y':yield1_last5_years, 'x_current': yield2_current, 'y_current': yield1_current, 'clean_num_obs': max(100, round(3*len(yield1_last5_years.values)/4))}) bf_qz_frame_short = pd.DataFrame() bf_qz_frame_long = pd.DataFrame() if (len(yield1) >= 40)&(len(yield2) >= 40): recent_zscore_list = [(yield1[-40+i]-yield_regress_output['alpha']-yield_regress_output['beta']*yield2[-40+i])/yield_regress_output['residualstd'] for i in range(40)] bf_qz_frame = pd.DataFrame.from_items([('bf_price', butterfly_price.values[-40:]), ('q',recent_quantile_list), ('zscore', recent_zscore_list)]) bf_qz_frame = np.round(bf_qz_frame, 8) bf_qz_frame.drop_duplicates(['bf_price'], take_last=True, inplace=True) # return bf_qz_frame bf_qz_frame_short = bf_qz_frame[(bf_qz_frame['zscore'] >= 0.6) & (bf_qz_frame['q'] >= 85)] bf_qz_frame_long = bf_qz_frame[(bf_qz_frame['zscore'] <= -0.6) & (bf_qz_frame['q'] <= 12)] if bf_qz_frame_short.empty: short_price_limit = np.NAN else: short_price_limit = bf_qz_frame_short['bf_price'].min() if bf_qz_frame_long.empty: long_price_limit = np.NAN else: long_price_limit = bf_qz_frame_long['bf_price'].max() zscore1= yield_regress_output['zscore'] rsquared1= yield_regress_output['rsquared'] zscore2= yield_regress_output_last5_years['zscore'] rsquared2= yield_regress_output_last5_years['rsquared'] second_spread_weight_1 = yield_regress_output['beta'] second_spread_weight_2 = yield_regress_output_last5_years['beta'] butterfly_5_change = data_last5_years['c1']['change_5']\ - (1+second_spread_weight_1)*data_last5_years['c2']['change_5']\ + second_spread_weight_1*data_last5_years['c3']['change_5'] butterfly_5_change_current = current_data['c1']['change_5']\ - (1+second_spread_weight_1)*current_data['c2']['change_5']\ + second_spread_weight_1*current_data['c3']['change_5'] butterfly_1_change = data_last5_years['c1']['change_1']\ - (1+second_spread_weight_1)*data_last5_years['c2']['change_1']\ + second_spread_weight_1*data_last5_years['c3']['change_1'] percentile_vector = stats.get_number_from_quantile(y=butterfly_5_change.values, quantile_list=[1, 15, 85, 99], clean_num_obs=max(100, round(3*len(butterfly_5_change.values)/4))) downside = contract_multiplier*(percentile_vector[0]+percentile_vector[1])/2 upside = contract_multiplier*(percentile_vector[2]+percentile_vector[3])/2 recent_5day_pnl = contract_multiplier*butterfly_5_change_current residuals = yield1-yield_regress_output['alpha']-yield_regress_output['beta']*yield2 regime_change_ind = (residuals[last5_years_indx].mean()-residuals.mean())/residuals.std() contract_seasonality_ind = (residuals[aligned_data['c1']['ticker_month'] == current_data['c1']['ticker_month']].mean()-residuals.mean())/residuals.std() yield1_quantile_list = stats.get_number_from_quantile(y=yield1, quantile_list=[10, 90]) yield2_quantile_list = stats.get_number_from_quantile(y=yield2, quantile_list=[10, 90]) noise_ratio = (yield1_quantile_list[1]-yield1_quantile_list[0])/(yield2_quantile_list[1]-yield2_quantile_list[0]) daily_noise_recent = stats.get_stdev(x=butterfly_1_change.values[-20:], clean_num_obs=15) daily_noise_past = stats.get_stdev(x=butterfly_1_change.values, clean_num_obs=max(100, round(3*len(butterfly_1_change.values)/4))) recent_vol_ratio = daily_noise_recent/daily_noise_past alpha1 = yield_regress_output['alpha'] residuals_last5_years = residuals[last5_years_indx] residuals_last2_months = residuals[last2_months_indx] residual_current = yield1_current-alpha1-second_spread_weight_1*yield2_current z3 = (residual_current-residuals_last5_years.mean())/residuals.std() z4 = (residual_current-residuals_last2_months.mean())/residuals.std() yield_change = (alpha1+second_spread_weight_1*yield2_current-yield1_current)/(1+second_spread_weight_1) new_yield1 = yield1_current + yield_change new_yield2 = yield2_current - yield_change price_change1 = 100*((price_2*(new_yield1+100)/100)-price_1)/(200+new_yield1) price_change2 = 100*((price_3*(new_yield2+100)/100)-price_2)/(200+new_yield2) theo_pnl = contract_multiplier*(2*price_change1-2*second_spread_weight_1*price_change2) aligned_data['residuals'] = residuals aligned_output['aligned_data'] = aligned_data grouped = aligned_data.groupby(aligned_data['c1']['cont_indx']) aligned_data['shifted_residuals'] = grouped['residuals'].shift(-5) aligned_data['residual_change'] = aligned_data['shifted_residuals']-aligned_data['residuals'] mean_reversion = stats.get_regression_results({'x':aligned_data['residuals'].values, 'y':aligned_data['residual_change'].values, 'clean_num_obs': max(100, round(3*len(yield1.values)/4))}) theo_spread_move_output = su.calc_theo_spread_move_from_ratio_normalization(ratio_time_series=price_ratio.values[-40:], starting_quantile=qf, num_price=linear_interp_price2_current, den_price=current_data['c2']['close_price'], favorable_quantile_move_list=[5, 10, 15, 20, 25]) theo_pnl_list = [x*contract_multiplier*2 for x in theo_spread_move_output['theo_spread_move_list']] return {'aligned_output': aligned_output, 'q': q, 'qf': qf, 'theo_pnl_list': theo_pnl_list, 'ratio_target_list': theo_spread_move_output['ratio_target_list'], 'weight1': weight1, 'weight2': weight2, 'weight3': weight3, 'zscore1': zscore1, 'rsquared1': rsquared1, 'zscore2': zscore2, 'rsquared2': rsquared2, 'zscore3': z3, 'zscore4': z4, 'zscore5': zscore1-regime_change_ind, 'zscore6': zscore1-contract_seasonality_ind, 'zscore7': zscore1-regime_change_ind-contract_seasonality_ind, 'theo_pnl': theo_pnl, 'regime_change_ind' : regime_change_ind,'contract_seasonality_ind': contract_seasonality_ind, 'second_spread_weight_1': second_spread_weight_1, 'second_spread_weight_2': second_spread_weight_2, 'downside': downside, 'upside': upside, 'yield1': yield1, 'yield2': yield2, 'yield1_current': yield1_current, 'yield2_current': yield2_current, 'bf_price': butterfly_price_current, 'short_price_limit': short_price_limit,'long_price_limit':long_price_limit, 'noise_ratio': noise_ratio, 'alpha1': alpha1, 'alpha2': yield_regress_output_last5_years['alpha'], 'residual_std1': yield_regress_output['residualstd'], 'residual_std2': yield_regress_output_last5_years['residualstd'], 'recent_vol_ratio': recent_vol_ratio, 'recent_5day_pnl': recent_5day_pnl, 'price_1': price_1, 'price_2': price_2, 'price_3': price_3, 'last5_years_indx': last5_years_indx, 'price_ratio': price_ratio, 'mean_reversion_rsquared': mean_reversion['rsquared'], 'mean_reversion_signif' : (mean_reversion['conf_int'][1, :] < 0).all()}
def get_futures_spread_carry_signals(**kwargs): ticker_list = kwargs['ticker_list'] date_to = kwargs['date_to'] if 'tr_dte_list' in kwargs.keys(): tr_dte_list = kwargs['tr_dte_list'] else: tr_dte_list = [exp.get_futures_days2_expiration({'ticker': x,'date_to': date_to}) for x in ticker_list] if 'aggregation_method' in kwargs.keys() and 'contracts_back' in kwargs.keys(): aggregation_method = kwargs['aggregation_method'] contracts_back = kwargs['contracts_back'] else: amcb_output = opUtil.get_aggregation_method_contracts_back(cmi.get_contract_specs(ticker_list[0])) aggregation_method = amcb_output['aggregation_method'] contracts_back = amcb_output['contracts_back'] if 'use_last_as_current' in kwargs.keys(): use_last_as_current = kwargs['use_last_as_current'] else: use_last_as_current = False 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 [cmi.get_contract_specs(ticker_list[0])['ticker_head']]} if 'contract_multiplier' in kwargs.keys(): contract_multiplier = kwargs['contract_multiplier'] else: contract_multiplier = cmi.contract_multiplier[cmi.get_contract_specs(ticker_list[0])['ticker_head']] if 'datetime5_years_ago' in kwargs.keys(): datetime5_years_ago = kwargs['datetime5_years_ago'] else: date5_years_ago = cu.doubledate_shift(date_to,5*365) datetime5_years_ago = cu.convert_doubledate_2datetime(date5_years_ago) if 'datetime2_months_ago' in kwargs.keys(): datetime2_months_ago = kwargs['datetime2_months_ago'] else: date2_months_ago = cu.doubledate_shift(date_to,60) datetime2_months_ago = cu.convert_doubledate_2datetime(date2_months_ago) aligned_output = opUtil.get_aligned_futures_data(contract_list=ticker_list, tr_dte_list=tr_dte_list, aggregation_method=aggregation_method, contracts_back=contracts_back, date_to=date_to, futures_data_dictionary=futures_data_dictionary, use_last_as_current=use_last_as_current) aligned_data = aligned_output['aligned_data'] current_data = aligned_output['current_data'] last5_years_indx = aligned_data['settle_date']>=datetime5_years_ago data_last5_years = aligned_data[last5_years_indx] ticker1_list = [current_data['c' + str(x+1)]['ticker'] for x in range(len(ticker_list)-1)] ticker2_list = [current_data['c' + str(x+2)]['ticker'] for x in range(len(ticker_list)-1)] yield_current_list = [100*(current_data['c' + str(x+1)]['close_price']- current_data['c' + str(x+2)]['close_price'])/ current_data['c' + str(x+2)]['close_price'] for x in range(len(ticker_list)-1)] price_current_list = [current_data['c' + str(x+1)]['close_price']-current_data['c' + str(x+2)]['close_price'] for x in range(len(ticker_list)-1)] yield_history = [100*(aligned_data['c' + str(x+1)]['close_price']- aligned_data['c' + str(x+2)]['close_price'])/ aligned_data['c' + str(x+2)]['close_price'] for x in range(len(ticker_list)-1)] change_5_history = [data_last5_years['c' + str(x+1)]['change_5']- data_last5_years['c' + str(x+2)]['change_5'] for x in range(len(ticker_list)-1)] change5 = [contract_multiplier*(current_data['c' + str(x+1)]['change5']- current_data['c' + str(x+2)]['change5']) for x in range(len(ticker_list)-1)] change10 = [contract_multiplier*(current_data['c' + str(x+1)]['change10']- current_data['c' + str(x+2)]['change10']) for x in range(len(ticker_list)-1)] change20 = [contract_multiplier*(current_data['c' + str(x+1)]['change20']- current_data['c' + str(x+2)]['change20']) for x in range(len(ticker_list)-1)] front_tr_dte = [current_data['c' + str(x+1)]['tr_dte'] for x in range(len(ticker_list)-1)] q_list = [stats.get_quantile_from_number({'x': yield_current_list[x], 'y': yield_history[x].values, 'clean_num_obs': max(100, round(3*len(yield_history[x].values)/4))}) for x in range(len(ticker_list)-1)] percentile_vector = [stats.get_number_from_quantile(y=change_5_history[x].values, quantile_list=[1, 15, 85, 99], clean_num_obs=max(100, round(3*len(change_5_history[x].values)/4))) for x in range(len(ticker_list)-1)] q1 = [x[0] for x in percentile_vector] q15 = [x[1] for x in percentile_vector] q85 = [x[2] for x in percentile_vector] q99 = [x[3] for x in percentile_vector] downside = [contract_multiplier*(q1[x]+q15[x])/2 for x in range(len(q1))] upside = [contract_multiplier*(q85[x]+q99[x])/2 for x in range(len(q1))] carry = [contract_multiplier*(price_current_list[x]-price_current_list[x+1]) for x in range(len(q_list)-1)] q_carry = [q_list[x]-q_list[x+1] for x in range(len(q_list)-1)] reward_risk = [5*carry[x]/((front_tr_dte[x+1]-front_tr_dte[x])*abs(downside[x+1])) if carry[x]>0 else 5*carry[x]/((front_tr_dte[x+1]-front_tr_dte[x])*upside[x+1]) for x in range(len(carry))] return pd.DataFrame.from_items([('ticker1',ticker1_list), ('ticker2',ticker2_list), ('ticker_head',cmi.get_contract_specs(ticker_list[0])['ticker_head']), ('front_tr_dte',front_tr_dte), ('carry',[np.NAN]+carry), ('q_carry',[np.NAN]+q_carry), ('reward_risk',[np.NAN]+reward_risk), ('price',price_current_list), ('q',q_list), ('upside',upside), ('downside',downside), ('change5',change5), ('change10',change10), ('change20',change20)])
def get_strategy_pnl(**kwargs): alias = kwargs['alias'] con = msu.get_my_sql_connection(**kwargs) #print(alias) strategy_info = ts.get_strategy_info_from_alias(alias=alias, con=con) if 'as_of_date' in kwargs.keys(): as_of_date = kwargs['as_of_date'] else: as_of_date = exp.doubledate_shift_bus_days() open_date = int(strategy_info['open_date'].strftime('%Y%m%d')) close_date = int(strategy_info['close_date'].strftime('%Y%m%d')) if close_date>as_of_date: close_date = as_of_date bus_day_list = exp.get_bus_day_list(date_from=open_date,date_to=close_date) trades_frame = ts.get_trades_4strategy_alias(alias=alias,con=con) ticker_head_list = [cmi.get_contract_specs(x)['ticker_head'] for x in trades_frame['ticker']] unique_ticker_head_list = list(set(ticker_head_list)) 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 unique_ticker_head_list} trades_frame['contract_multiplier'] = [cmi.contract_multiplier[x] for x in ticker_head_list] trades_frame['t_cost'] = [cmi.t_cost[x] for x in ticker_head_list] pnl_path = [get_strategy_pnl_4day(alias=alias,pnl_date=x,con=con, trades_frame=trades_frame, futures_data_dictionary=futures_data_dictionary) for x in bus_day_list] pnl_per_tickerhead_list = [x['pnl_per_tickerhead'] for x in pnl_path] pnl_per_tickerhead = pd.concat(pnl_per_tickerhead_list, axis=1) pnl_per_tickerhead = pnl_per_tickerhead[['pnl_total']] pnl_per_tickerhead = pnl_per_tickerhead.transpose() if len(unique_ticker_head_list)>1: zero_indx = [[x not in y.index for y in pnl_per_tickerhead_list] for x in pnl_per_tickerhead.columns] for i in range(len(pnl_per_tickerhead.columns)): pnl_per_tickerhead.iloc[:, i][zero_indx[i]] = 0 pnl_per_tickerhead['settle_date'] = bus_day_list pnl_per_tickerhead.reset_index(inplace=True,drop=True) pnl_frame = pd.DataFrame(pnl_path) pnl_frame['settle_date'] = bus_day_list if 'con' not in kwargs.keys(): con.close() return {'pnl_frame': pnl_frame[['settle_date','position_pnl','intraday_pnl','t_cost','total_pnl']], 'pnl_per_tickerhead': pnl_per_tickerhead, 'daily_pnl': pnl_frame['total_pnl'].values[-1], 'total_pnl': pnl_frame['total_pnl'].sum()}
def get_results_4ticker(**kwargs): ticker = kwargs['ticker'] date_to = kwargs['date_to'] ticker_frame = gfp.get_futures_price_preloaded(ticker=ticker, settle_date_to=date_to) ticker_frame['close_diff'] = ticker_frame['close_price'].diff() daily_sd = np.std(ticker_frame['close_diff'].iloc[-41:-1]) ticker_frame['ma50'] = ticker_frame['close_price'].rolling( window=50, center=False).mean() ticker_frame['ma200'] = ticker_frame['close_price'].rolling( window=200, center=False).mean() if ticker_frame['close_price'].iloc[-2] > ticker_frame['ma50'].iloc[-2]: trend1 = 1 else: trend1 = -1 if ticker_frame['ma50'].iloc[-2] > ticker_frame['ma200'].iloc[-2]: trend2 = 1 else: trend2 = -1 candle_frame = qd.get_continuous_bar_data(ticker=ticker, date_to=date_to, num_days_back=20) ticker_head = cmi.get_contract_specs(ticker)['ticker_head'] candle_frame['ewma300'] = candle_frame['close'].ewm( span=300, min_periods=250, adjust=True, ignore_na=False).mean() candle_frame['ewma50'] = candle_frame['close'].ewm(span=50, min_periods=40, adjust=True, ignore_na=False).mean() candle_frame['ma5'] = candle_frame['close'].rolling(window=5, center=False).mean() candle_frame['ewma300D'] = candle_frame['ewma300'] - candle_frame[ 'ewma300'].shift(60) candle_frame['ewma300DN'] = candle_frame['ewma300D'] / daily_sd candle_frame[ 'ewma50D'] = candle_frame['ewma50'] - candle_frame['ewma50'].shift(10) candle_frame['min14'] = candle_frame['low'].rolling(window=14, center=False).min() candle_frame['max14'] = candle_frame['high'].rolling(window=14, center=False).max() candle_frame['william'] = -100 * ( candle_frame['max14'] - candle_frame['close']) / ( candle_frame['max14'] - candle_frame['min14']) candle_frame['datetime'] = [ x.replace(hour=0, second=0, minute=0) for x in candle_frame.index ] candle_frame['obs_no'] = range(len(candle_frame.index)) candle_frame['bullishW'] = candle_frame['william'] > -20 candle_frame['bearishW'] = candle_frame['william'] < -80 candle_frame['bullishW'] = candle_frame['bullishW'].astype(int) candle_frame['bearishW'] = candle_frame['bearishW'].astype(int) candle_frame = candle_frame[np.isfinite(candle_frame['ewma300D'])] candle_frame['ewma300DS'] = np.sign(candle_frame['ewma300D']) candle_frame['ewma300DSDiff'] = abs(candle_frame['ewma300DS'].diff()) turning_points = candle_frame[candle_frame['ewma300DSDiff'] != 0] turning_points['turning_points'] = turning_points['obs_no'] merged_frame = pd.concat([candle_frame, turning_points['turning_points']], axis=1) merged_frame['turning_points'].iloc[0] = 0 merged_frame['turning_points'] = merged_frame['turning_points'].fillna( method='ffill') merged_frame[ 'trend_age'] = merged_frame['obs_no'] - merged_frame['turning_points'] merged_frame['bullishWCumsum'] = merged_frame.groupby( 'turning_points')['bullishW'].transform(pd.Series.cumsum) merged_frame['bearishWCumsum'] = merged_frame.groupby( 'turning_points')['bearishW'].transform(pd.Series.cumsum) candle_frame = merged_frame candle_frame = candle_frame.dropna().reset_index(drop=True, inplace=False) date_timeto = cu.convert_doubledate_2datetime(date_to) daily_frame = candle_frame[candle_frame['datetime'] == date_timeto] daily_frame.reset_index(drop=True, inplace=True) tick_size = cmi.tick_size[ticker_head] latest_trade_exit_hour_minute = get_latest_trade_exit_hour_minute( ticker_head) current_position = 0 direction_list = [] entry_price_list = [] exit_price_list = [] entry_index_list = [] exit_index_list = [] entry_hour_minute_list = [] stop_price_list = [] target_price_list = [] ewma300DN_list = [] trend_age_list = [] bullishWCumsum_list = [] bearishWCumsum_list = [] stop_adjustment_possible_Q = False long_trade_possible_Q = False short_trade_possible_Q = False breakout_price = np.nan for i in range(2, len(daily_frame.index)): if (daily_frame['ewma300D'].iloc[i] < 0) | (daily_frame['william'].iloc[i] <= -80): long_trade_possible_Q = False if (daily_frame['ewma300D'].iloc[i] > 0) | (daily_frame['william'].iloc[i] >= -20): short_trade_possible_Q = False if long_trade_possible_Q and (daily_frame['high'].iloc[i] > breakout_price + tick_size) \ and (daily_frame['hour_minute'].iloc[i] <= 1100): long_trade_possible_Q = False current_position = 1 direction_list.append(current_position) ewma300DN_list.append(daily_frame['ewma300DN'].iloc[i - 1]) trend_age_list.append(daily_frame['trend_age'].iloc[i - 1]) bullishWCumsum_list.append(daily_frame['bullishWCumsum'].iloc[i - 1]) bearishWCumsum_list.append(daily_frame['bearishWCumsum'].iloc[i - 1]) entry_index_list.append(i) entry_hour_minute_list.append(daily_frame['hour_minute'].iloc[i]) entry_price = breakout_price + 1.5 * tick_size entry_price_list.append(entry_price) stop_price_list.append(swing_low - tick_size) target_price_list.append(2 * entry_price - swing_low) breakout_price = np.nan continue if (current_position == 0) and (daily_frame['ewma300D'].iloc[i] > 0) and (daily_frame['william'].iloc[i - 1] <= -80) \ and (daily_frame['william'].iloc[i] > -80) and (daily_frame['hour_minute'].iloc[i] <= 1100) and (daily_frame['hour_minute'].iloc[i] >= 830): long_trade_possible_Q = True breakout_price = daily_frame['high'].iloc[i] for j in range(len(daily_frame.index)): if j == 0: swing_low = daily_frame['low'].iloc[i - 1] elif daily_frame['low'].iloc[i - 1 - j] <= swing_low: swing_low = daily_frame['low'].iloc[i - 1 - j] elif daily_frame['low'].iloc[i - 1 - j] > swing_low: break if short_trade_possible_Q and (daily_frame['low'].iloc[i] < breakout_price - tick_size) \ and (daily_frame['hour_minute'].iloc[i] <= 1100): short_trade_possible_Q = False current_position = -1 direction_list.append(current_position) ewma300DN_list.append(daily_frame['ewma300DN'].iloc[i - 1]) trend_age_list.append(daily_frame['trend_age'].iloc[i - 1]) bullishWCumsum_list.append(daily_frame['bullishWCumsum'].iloc[i - 1]) bearishWCumsum_list.append(daily_frame['bearishWCumsum'].iloc[i - 1]) entry_index_list.append(i) entry_hour_minute_list.append(daily_frame['hour_minute'].iloc[i]) entry_price = breakout_price - 1.5 * tick_size entry_price_list.append(entry_price) stop_price_list.append(swing_high + tick_size) target_price_list.append(2 * entry_price - swing_high) breakout_price = np.nan continue if (current_position == 0) and (daily_frame['ewma300D'].iloc[i] < 0) and (daily_frame['william'].iloc[i - 1] >= -20) \ and (daily_frame['william'].iloc[i] < -20) and (daily_frame['hour_minute'].iloc[i] <= 1100) and (daily_frame['hour_minute'].iloc[i] >= 830): short_trade_possible_Q = True breakout_price = daily_frame['high'].iloc[i] for j in range(len(daily_frame.index)): if j == 0: swing_high = daily_frame['high'].iloc[i - 1] elif daily_frame['high'].iloc[i - 1 - j] >= swing_high: swing_high = daily_frame['high'].iloc[i - 1 - j] elif daily_frame['high'].iloc[i - 1 - j] < swing_high: break if (current_position > 0) and stop_adjustment_possible_Q and ( daily_frame['close'].iloc[i-2] < daily_frame['ma5'].iloc[i-2]) \ and (daily_frame['close'].iloc[i-1] < daily_frame['ma5'].iloc[i-1]): stop_price_list[-1] = min(daily_frame['low'].iloc[i - 2], daily_frame['low'].iloc[i - 1]) if (current_position < 0) and stop_adjustment_possible_Q and ( daily_frame['close'].iloc[i-2] > daily_frame['ma5'].iloc[i-2]) \ and (daily_frame['close'].iloc[i-1] > daily_frame['ma5'].iloc[i-1]): stop_price_list[-1] = max(daily_frame['high'].iloc[i - 2], daily_frame['high'].iloc[i - 1]) if (current_position > 0) and ((daily_frame['hour_minute'].iloc[i] >= latest_trade_exit_hour_minute) | (i == len(daily_frame.index) - 1)): current_position = 0 exit_price_list.append(daily_frame['open'].iloc[i] - 0.5 * tick_size) exit_index_list.append(i) stop_adjustment_possible_Q = False if (current_position < 0) and ((daily_frame['hour_minute'].iloc[i] >= latest_trade_exit_hour_minute) | (i == len(daily_frame.index) - 1)): current_position = 0 exit_price_list.append(daily_frame['open'].iloc[i] + 0.5 * tick_size) exit_index_list.append(i) stop_adjustment_possible_Q = False if (current_position > 0) and (daily_frame['low'].iloc[i] <= stop_price_list[-1]): current_position = 0 exit_price_list.append(stop_price_list[-1] - 0.5 * tick_size) exit_index_list.append(i) stop_adjustment_possible_Q = False if (current_position < 0) and (daily_frame['high'].iloc[i] >= stop_price_list[-1]): current_position = 0 exit_price_list.append(stop_price_list[-1] + 0.5 * tick_size) exit_index_list.append(i) stop_adjustment_possible_Q = False if (current_position > 0) and (daily_frame['high'].iloc[i] >= target_price_list[-1]): stop_adjustment_possible_Q = True if (current_position < 0) and (daily_frame['low'].iloc[i] <= target_price_list[-1]): stop_adjustment_possible_Q = True trades_frame = pd.DataFrame.from_items([ ('direction', direction_list), ('entry_price', entry_price_list), ('exit_price', exit_price_list), ('entry_index', entry_index_list), ('exit_index', exit_index_list), ('entry_hour_minute', entry_hour_minute_list), ('target_price', target_price_list), ('ewma300DN', ewma300DN_list), ('trend_age', trend_age_list), ('bullishWCumsum', bullishWCumsum_list), ('bearishWCumsum', bearishWCumsum_list) ]) trades_frame['pnl'] = ( trades_frame['exit_price'] - trades_frame['entry_price']) * trades_frame['direction'] trades_frame['pnl_dollar'] = cmi.contract_multiplier[ ticker_head] * trades_frame['pnl'] trades_frame['stop_loss'] = abs(trades_frame['entry_price'] - trades_frame['target_price']) trades_frame['daily_sd'] = daily_sd trades_frame['normalized_stop_loss'] = trades_frame['stop_loss'] / daily_sd trades_frame['pnl_normalized'] = trades_frame['pnl'] / daily_sd trades_frame['ticker_head'] = ticker_head trades_frame['ticker'] = ticker trades_frame['trend1'] = trend1 trades_frame['trend2'] = trend2 trades_frame['trade_date'] = date_to return {'trades_frame': trades_frame, 'daily_frame': daily_frame}
def get_scv_signals(**kwargs): ticker = kwargs['ticker'] date_to = kwargs['date_to'] con = msu.get_my_sql_connection(**kwargs) 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 [cmi.get_contract_specs(ticker)['ticker_head']] } aligned_indicators_output = ops.get_aligned_option_indicators( ticker_list=[ticker], settle_date=date_to, con=con) if not aligned_indicators_output['success']: return { 'downside': np.NaN, 'upside': np.NaN, 'theta': np.NaN, 'realized_vol_forecast': np.NaN, 'real_vol20_current': np.NaN, 'imp_vol': np.NaN, 'imp_vol_premium': np.NaN, 'q': np.NaN } hist = aligned_indicators_output['hist'] current = aligned_indicators_output['current'] vcs_output = vcs.generate_vcs_sheet_4date(date_to=date_to, con=con) if 'con' not in kwargs.keys(): con.close() clean_indx = hist['c1']['profit5'].notnull() clean_data = hist[clean_indx] if clean_data.empty: downside = np.NaN upside = np.NaN else: last_available_align_date = clean_data.index[-1] clean_data = clean_data[clean_data.index >= last_available_align_date - dt.timedelta(5 * 365)] profit5 = clean_data['c1']['profit5'] percentile_vector = stats.get_number_from_quantile( y=profit5.values, quantile_list=[1, 15, 85, 99], clean_num_obs=max(100, round(3 * len(profit5.values) / 4))) downside = (percentile_vector[0] + percentile_vector[1]) / 2 upside = (percentile_vector[2] + percentile_vector[3]) / 2 realized_vol_output = rvue.forecast_realized_vol_until_expiration( ticker=ticker, futures_data_dictionary=futures_data_dictionary, date_to=date_to) realized_vol_forecast = realized_vol_output['realized_vol_forecast'] real_vol20_current = realized_vol_output['real_vol20_current'] imp_vol = current['imp_vol'][0] imp_vol_premium = 100 * (imp_vol - realized_vol_forecast) / imp_vol q = np.NaN if vcs_output['success']: vcs_pairs = vcs_output['vcs_pairs'] selected_pairs = vcs_pairs[vcs_pairs['ticker2'] == ticker] if not selected_pairs.empty: q = 100 - selected_pairs['Q'].mean() return { 'downside': downside, 'upside': upside, 'theta': current['theta'][0], 'realized_vol_forecast': realized_vol_forecast, 'real_vol20_current': real_vol20_current, 'imp_vol': imp_vol, 'imp_vol_premium': imp_vol_premium, 'q': q }
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 get_aligned_futures_data(**kwargs): contract_list = kwargs['contract_list'] aggregation_method = kwargs['aggregation_method'] contracts_back = kwargs['contracts_back'] date_to = kwargs['date_to'] if 'use_last_as_current' in kwargs.keys(): use_last_as_current = kwargs['use_last_as_current'] else: use_last_as_current = False if 'tr_dte_list' in kwargs.keys(): tr_dte_list = kwargs['tr_dte_list'] else: tr_dte_list = [exp.get_futures_days2_expiration({'ticker': x,'date_to': date_to}) for x in contract_list] if 'futures_data_dictionary' in kwargs.keys(): futures_data_dictionary = kwargs['futures_data_dictionary'] else: ticker_head_list = [cmi.get_contract_specs(x)['ticker_head'] for x in contract_list] futures_data_dictionary = {x: gfp.get_futures_price_preloaded(ticker_head=x) for x in ticker_head_list} date_from = cu.doubledate_shift(date_to, 2*3650) date_to_datetime = cu.convert_doubledate_2datetime(date_to) date_from_datetime = cu.convert_doubledate_2datetime(date_from) tr_days_half_band_width_selected = tr_days_half_band_with[aggregation_method] num_contracts = len(contract_list) contract_specs_list = [cmi.get_contract_specs(x) for x in contract_list] data_frame_list = [] for i in range(num_contracts): futures_data_frame = futures_data_dictionary[contract_specs_list[i]['ticker_head']] selection_indx = (futures_data_frame['tr_dte'] >= tr_dte_list[i]-tr_days_half_band_width_selected)& \ (futures_data_frame['tr_dte'] <= tr_dte_list[i]+tr_days_half_band_width_selected)& \ (futures_data_frame['cal_dte'] >= 0)& \ (futures_data_frame['settle_date'] >= date_from_datetime) & \ (futures_data_frame['settle_date'] <= date_to_datetime) futures_data_frame = futures_data_frame[selection_indx] data_frame_list.append(futures_data_frame) cont_indx_list_rolls = [get_cont_indx_list_history({'current_year': x['ticker_year'], 'current_month': x['ticker_month_num'], 'aggregation_method': aggregation_method, 'contracts_back': contracts_back}) for x in contract_specs_list] merged_dataframe_list = [None]*contracts_back for i in range(contracts_back): if sum([(data_frame_list[j]['cont_indx'] == cont_indx_list_rolls[j][i]).any() for j in range(len(contract_list))])<len(contract_list): continue contract_data_list = [None]*num_contracts for k in range(num_contracts): contract_data_list[k] = data_frame_list[k][data_frame_list[k]['cont_indx']==cont_indx_list_rolls[k][i]] contract_data_list[k].set_index('settle_date',inplace=True) merged_dataframe_list[i] = pd.concat(contract_data_list, axis=1, join='inner',keys=['c'+ str(x+1) for x in range(num_contracts)]) aligned_dataframe = pd.concat(merged_dataframe_list) aligned_dataframe.sort_index(inplace=True) aligned_dataframe['tr_dte_match'] = abs(aligned_dataframe['c1']['tr_dte']-tr_dte_list[0]) aligned_dataframe['settle_date'] = aligned_dataframe.index aligned_dataframe.sort(['settle_date','tr_dte_match'],ascending=[True,True],inplace=True) aligned_dataframe.drop_duplicates('settle_date',inplace=True) if use_last_as_current: current_data = aligned_dataframe.iloc[-1] else: current_data = aligned_dataframe.loc[cu.convert_doubledate_2datetime(date_to)] return {'aligned_data': aligned_dataframe, 'current_data': current_data}
def get_intraday_trend_signals(**kwargs): ticker = kwargs['ticker'] date_to = kwargs['date_to'] datetime_to = cu.convert_doubledate_2datetime(date_to) breakout_method = 2 #print(ticker) ticker_head = cmi.get_contract_specs(ticker)['ticker_head'] contract_multiplier = cmi.contract_multiplier[ticker_head] ticker_class = cmi.ticker_class[ticker_head] daily_settles = gfp.get_futures_price_preloaded(ticker=ticker) daily_settles = daily_settles[daily_settles['settle_date'] <= datetime_to] daily_settles['ewma10'] = pd.ewma(daily_settles['close_price'], span=10) daily_settles['ewma50'] = pd.ewma(daily_settles['close_price'], span=50) if daily_settles['ewma10'].iloc[-1] > daily_settles['ewma50'].iloc[-1]: long_term_trend = 1 else: long_term_trend = -1 date_list = [exp.doubledate_shift_bus_days(double_date=date_to,shift_in_days=1)] date_list.append(date_to) intraday_data = opUtil.get_aligned_futures_data_intraday(contract_list=[ticker], date_list=date_list) intraday_data['time_stamp'] = [x.to_datetime() for x in intraday_data.index] intraday_data['hour_minute'] = [100*x.hour+x.minute for x in intraday_data['time_stamp']] end_hour = cmi.last_trade_hour_minute[ticker_head] start_hour = cmi.first_trade_hour_minute[ticker_head] if ticker_class in ['Ag']: start_hour1 = dt.time(0, 45, 0, 0) end_hour1 = dt.time(7, 45, 0, 0) selection_indx = [x for x in range(len(intraday_data.index)) if ((intraday_data['time_stamp'].iloc[x].time() < end_hour1) and(intraday_data['time_stamp'].iloc[x].time() >= start_hour1)) or ((intraday_data['time_stamp'].iloc[x].time() < end_hour) and(intraday_data['time_stamp'].iloc[x].time() >= start_hour))] else: 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)] selected_data = intraday_data.iloc[selection_indx] selected_data['mid_p'] = (selected_data['c1']['best_bid_p']+selected_data['c1']['best_ask_p'])/2 selected_data['ewma100'] = pd.ewma(selected_data['mid_p'], span=100) selected_data['ewma25'] = pd.ewma(selected_data['mid_p'], span=25) selected_data.reset_index(inplace=True,drop=True) datetime_to = cu.convert_doubledate_2datetime(date_to) range_start = dt.datetime.combine(datetime_to,dt.time(8,30,0,0)) range_end = dt.datetime.combine(datetime_to,dt.time(9,0,0,0)) first_30_minutes = selected_data[(selected_data['time_stamp'] >= range_start)& (selected_data['time_stamp'] <= range_end)] trading_data = selected_data[selected_data['time_stamp'] > range_end] trading_data_shifted = trading_data.shift(5) range_min = first_30_minutes['mid_p'].min() range_max = first_30_minutes['mid_p'].max() initial_range = range_max-range_min if breakout_method == 1: bullish_breakout = trading_data[(trading_data['mid_p'] > range_max)& (trading_data['mid_p'] < range_max+0.5*initial_range)& (trading_data_shifted['mid_p']<range_max)& (trading_data['ewma25'] > range_max)& (trading_data['mid_p'] > trading_data['ewma100'])] bearish_breakout = trading_data[(trading_data['mid_p'] < range_min)& (trading_data['mid_p'] > range_min-0.5*initial_range)& (trading_data_shifted['mid_p']>range_min)& (trading_data['ewma25'] < range_min)& (trading_data['mid_p'] < trading_data['ewma100'])] elif breakout_method == 2: bullish_breakout = pd.DataFrame() bearish_breakout = pd.DataFrame() if long_term_trend > 0: bullish_breakout = trading_data[(trading_data['mid_p'] > range_max)& (trading_data_shifted['mid_p']<range_max)& (long_term_trend == 1)& (trading_data['mid_p'] > trading_data['ewma100'])] elif long_term_trend < 0: bearish_breakout = trading_data[(trading_data['mid_p'] < range_min)& (trading_data_shifted['mid_p']>range_min)& (long_term_trend == -1)& (trading_data['mid_p'] < trading_data['ewma100'])] bullish_cross = trading_data[trading_data['mid_p'] > trading_data['ewma100']] bearish_cross = trading_data[trading_data['mid_p'] < trading_data['ewma100']] end_of_day_price = trading_data['mid_p'].iloc[-1] end_of_day_time_stamp = trading_data['time_stamp'].iloc[-1] valid_bearish_breakoutQ = False valid_bullish_breakoutQ = False bearish_breakout_price_entry = np.NaN bullish_breakout_price_entry = np.NaN if not bearish_breakout.empty: if bearish_breakout.index[0]+1 < trading_data.index[-1]: if trading_data['mid_p'].loc[bearish_breakout.index[0]+1]>range_min-0.5*initial_range: valid_bearish_breakoutQ = True bearish_breakout_price_entry = trading_data['mid_p'].loc[bearish_breakout.index[0]+1] bearish_breakout_time_stamp = trading_data['time_stamp'].loc[bearish_breakout.index[0]+1] if not bullish_breakout.empty: if bullish_breakout.index[0]+1<trading_data.index[-1]: if trading_data['mid_p'].loc[bullish_breakout.index[0]+1]<range_max+0.5*initial_range: valid_bullish_breakoutQ = True bullish_breakout_price_entry = trading_data['mid_p'].loc[bullish_breakout.index[0]+1] bullish_breakout_time_stamp = trading_data['time_stamp'].loc[bullish_breakout.index[0]+1] stop_loss = (range_max-range_min)*contract_multiplier pnl_list = [] direction_list = [] entry_time_list = [] exit_time_list = [] entry_price_list = [] exit_price_list = [] daily_trade_no_list = [] exit_type_list = [] ticker_list = [] if valid_bearish_breakoutQ: direction_list.append(-1) entry_time_list.append(bearish_breakout_time_stamp) entry_price_list.append(bearish_breakout_price_entry) daily_pnl = bearish_breakout_price_entry-end_of_day_price exit_price = end_of_day_price exit_type = 'eod' exit_time = end_of_day_time_stamp daily_trade_no = 1 #bullish_cross_stop_frame = bullish_cross[(bullish_cross['time_stamp'] > bearish_breakout_time_stamp)] #if (not bullish_cross_stop_frame.empty) and (bullish_cross_stop_frame.index[0]+1<trading_data.index[-1]): # daily_pnl = bearish_breakout_price_entry-trading_data['mid_p'].loc[bullish_cross_stop_frame.index[0]+1] # exit_price = trading_data['mid_p'].loc[bullish_cross_stop_frame.index[0]+1] # exit_type = 'oso' # exit_time = trading_data['time_stamp'].loc[bullish_cross_stop_frame.index[0]+1] #if valid_bullish_breakoutQ: # if bullish_breakout_time_stamp>bearish_breakout_time_stamp: # if bullish_breakout_time_stamp<exit_time: # daily_pnl = bearish_breakout_price_entry-bullish_breakout_price_entry # exit_price = bullish_breakout_price_entry # exit_type = 'fso' # exit_time = bullish_breakout_time_stamp # else: # daily_trade_no = 2 exit_time_list.append(exit_time) exit_type_list.append(exit_type) daily_trade_no_list.append(daily_trade_no) pnl_list.append(daily_pnl) exit_price_list.append(exit_price) ticker_list.append(ticker) if valid_bullish_breakoutQ: direction_list.append(1) entry_time_list.append(bullish_breakout_time_stamp) entry_price_list.append(bullish_breakout_price_entry) daily_pnl = end_of_day_price-bullish_breakout_price_entry exit_price = end_of_day_price exit_type = 'eod' exit_time = end_of_day_time_stamp daily_trade_no = 1 bearish_cross_stop_frame = bearish_cross[(bearish_cross['time_stamp'] > bullish_breakout_time_stamp)] #if (not bearish_cross_stop_frame.empty) and (bearish_cross_stop_frame.index[0]+1 < trading_data.index[-1]): # daily_pnl = trading_data['mid_p'].loc[bearish_cross_stop_frame.index[0]+1]-bullish_breakout_price_entry # exit_price = trading_data['mid_p'].loc[bearish_cross_stop_frame.index[0]+1] # exit_type = 'oso' # exit_time = trading_data['time_stamp'].loc[bearish_cross_stop_frame.index[0]+1] #if valid_bearish_breakoutQ: # if bearish_breakout_time_stamp>bullish_breakout_time_stamp: # if bearish_breakout_time_stamp<exit_time: # daily_pnl = bearish_breakout_price_entry-bullish_breakout_price_entry # exit_price = bearish_breakout_price_entry # exit_type = 'fso' # exit_time = bearish_breakout_time_stamp # else: # daily_trade_no = 2 exit_time_list.append(exit_time) exit_type_list.append(exit_type) daily_trade_no_list.append(daily_trade_no) pnl_list.append(daily_pnl) exit_price_list.append(exit_price) ticker_list.append(ticker) pnl_frame = pd.DataFrame.from_items([('ticker', ticker_list), ('ticker_head',ticker_head), ('direction', direction_list), ('entry_price', entry_price_list), ('exit_price', exit_price_list), ('pnl', pnl_list), ('entry_time', entry_time_list), ('exit_time', exit_time_list), ('exit_type', exit_type_list), ('daily_trade_no', daily_trade_no_list)]) pnl_frame['pnl'] = pnl_frame['pnl']*contract_multiplier return {'intraday_data': selected_data, 'range_min': range_min, 'range_max':range_max,'pnl_frame':pnl_frame,'stop_loss':stop_loss}
def get_intraday_spread_signals(**kwargs): ticker_list = kwargs['ticker_list'] date_to = kwargs['date_to'] 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] ticker_class_list = [cmi.ticker_class[x] for x in ticker_head_list] print('-'.join(ticker_list)) if 'tr_dte_list' in kwargs.keys(): tr_dte_list = kwargs['tr_dte_list'] else: tr_dte_list = [exp.get_days2_expiration(ticker=x,date_to=date_to, instrument='futures')['tr_dte'] for x in ticker_list] weights_output = sutil.get_spread_weights_4contract_list(ticker_head_list=ticker_head_list) if 'aggregation_method' in kwargs.keys() and 'contracts_back' in kwargs.keys(): aggregation_method = kwargs['aggregation_method'] contracts_back = kwargs['contracts_back'] else: amcb_output = [opUtil.get_aggregation_method_contracts_back(cmi.get_contract_specs(x)) for x in ticker_list] aggregation_method = max([x['aggregation_method'] for x in amcb_output]) contracts_back = min([x['contracts_back'] for x in amcb_output]) 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 list(set(ticker_head_list))} if 'use_last_as_current' in kwargs.keys(): use_last_as_current = kwargs['use_last_as_current'] else: use_last_as_current = True if 'datetime5_years_ago' in kwargs.keys(): datetime5_years_ago = kwargs['datetime5_years_ago'] else: date5_years_ago = cu.doubledate_shift(date_to,5*365) datetime5_years_ago = cu.convert_doubledate_2datetime(date5_years_ago) if 'num_days_back_4intraday' in kwargs.keys(): num_days_back_4intraday = kwargs['num_days_back_4intraday'] else: num_days_back_4intraday = 5 contract_multiplier_list = [cmi.contract_multiplier[x] for x in ticker_head_list] aligned_output = opUtil.get_aligned_futures_data(contract_list=ticker_list, tr_dte_list=tr_dte_list, aggregation_method=aggregation_method, contracts_back=contracts_back, date_to=date_to, futures_data_dictionary=futures_data_dictionary, use_last_as_current=use_last_as_current) aligned_data = aligned_output['aligned_data'] current_data = aligned_output['current_data'] spread_weights = weights_output['spread_weights'] portfolio_weights = weights_output['portfolio_weights'] aligned_data['spread'] = 0 aligned_data['spread_pnl_1'] = 0 aligned_data['spread_pnl1'] = 0 spread_settle = 0 last5_years_indx = aligned_data['settle_date']>=datetime5_years_ago num_contracts = len(ticker_list) for i in range(num_contracts): aligned_data['spread'] = aligned_data['spread']+aligned_data['c' + str(i+1)]['close_price']*spread_weights[i] spread_settle = spread_settle + current_data['c' + str(i+1)]['close_price']*spread_weights[i] aligned_data['spread_pnl_1'] = aligned_data['spread_pnl_1']+aligned_data['c' + str(i+1)]['change_1']*portfolio_weights[i]*contract_multiplier_list[i] aligned_data['spread_pnl1'] = aligned_data['spread_pnl1']+aligned_data['c' + str(i+1)]['change1_instant']*portfolio_weights[i]*contract_multiplier_list[i] aligned_data['spread_normalized'] = aligned_data['spread']/aligned_data['c1']['close_price'] data_last5_years = aligned_data[last5_years_indx] percentile_vector = stats.get_number_from_quantile(y=data_last5_years['spread_pnl_1'].values, quantile_list=[1, 15, 85, 99], clean_num_obs=max(100, round(3*len(data_last5_years.index)/4))) downside = (percentile_vector[0]+percentile_vector[1])/2 upside = (percentile_vector[2]+percentile_vector[3])/2 date_list = [exp.doubledate_shift_bus_days(double_date=date_to,shift_in_days=x) for x in reversed(range(1,num_days_back_4intraday))] date_list.append(date_to) intraday_data = opUtil.get_aligned_futures_data_intraday(contract_list=ticker_list, date_list=date_list) 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()) end_hour = min([cmi.last_trade_hour_minute[x] for x in ticker_head_list]) start_hour = max([cmi.first_trade_hour_minute[x] for x in ticker_head_list]) trade_start_hour = dt.time(9, 30, 0, 0) if 'Ag' in ticker_class_list: start_hour1 = dt.time(0, 45, 0, 0) end_hour1 = dt.time(7, 45, 0, 0) selection_indx = [x for x in range(len(intraday_data.index)) if ((intraday_data['time_stamp'].iloc[x].time() < end_hour1) and(intraday_data['time_stamp'].iloc[x].time() >= start_hour1)) or ((intraday_data['time_stamp'].iloc[x].time() < end_hour) and(intraday_data['time_stamp'].iloc[x].time() >= start_hour))] else: 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['spread'] = 0 for i in range(num_contracts): intraday_data['c' + str(i+1), 'mid_p'] = (intraday_data['c' + str(i+1)]['best_bid_p'] + intraday_data['c' + str(i+1)]['best_ask_p'])/2 intraday_data['spread'] = intraday_data['spread']+intraday_data['c' + str(i+1)]['mid_p']*spread_weights[i] unique_settle_dates = intraday_data['settle_date'].unique() intraday_data['spread1'] = np.nan for i in range(len(unique_settle_dates)-1): if (intraday_data['settle_date'] == unique_settle_dates[i]).sum() == \ (intraday_data['settle_date'] == unique_settle_dates[i+1]).sum(): intraday_data.loc[intraday_data['settle_date'] == unique_settle_dates[i],'spread1'] = \ intraday_data['spread'][intraday_data['settle_date'] == unique_settle_dates[i+1]].values intraday_data = intraday_data[intraday_data['settle_date'].notnull()] intraday_mean = intraday_data['spread'].mean() intraday_std = intraday_data['spread'].std() intraday_data_last2days = intraday_data[intraday_data['settle_date'] >= cu.convert_doubledate_2datetime(date_list[-2]).date()] intraday_data_yesterday = intraday_data[intraday_data['settle_date'] == cu.convert_doubledate_2datetime(date_list[-1]).date()] intraday_mean2 = intraday_data_last2days['spread'].mean() intraday_std2 = intraday_data_last2days['spread'].std() intraday_mean1 = intraday_data_yesterday['spread'].mean() intraday_std1 = intraday_data_yesterday['spread'].std() intraday_z = (spread_settle-intraday_mean)/intraday_std num_obs_intraday = len(intraday_data.index) num_obs_intraday_half = round(num_obs_intraday/2) intraday_tail = intraday_data.tail(num_obs_intraday_half) num_positives = sum(intraday_tail['spread'] > intraday_data['spread'].mean()) num_negatives = sum(intraday_tail['spread'] < intraday_data['spread'].mean()) recent_trend = 100*(num_positives-num_negatives)/(num_positives+num_negatives) pnl_frame = ifs.get_pnl_4_date_range(date_to=date_to, num_bus_days_back=20, ticker_list=ticker_list) if (len(pnl_frame.index)>15)&(pnl_frame['total_pnl'].std() != 0): historical_sharp = (250**(0.5))*pnl_frame['total_pnl'].mean()/pnl_frame['total_pnl'].std() else: historical_sharp = np.nan return {'downside': downside, 'upside': upside,'intraday_data': intraday_data, 'z': intraday_z,'recent_trend': recent_trend, 'intraday_mean': intraday_mean, 'intraday_std': intraday_std, 'intraday_mean2': intraday_mean2, 'intraday_std2': intraday_std2, 'intraday_mean1': intraday_mean1, 'intraday_std1': intraday_std1, 'aligned_output': aligned_output, 'spread_settle': spread_settle, 'data_last5_years': data_last5_years,'historical_sharp':historical_sharp}
def get_simple_rate(**kwargs): as_of_date = kwargs["as_of_date"] date_to = kwargs["date_to"] if "date_from" in kwargs.keys(): date_from = kwargs["date_from"] else: date_from = as_of_date if "ticker_head" in kwargs.keys(): ticker_head = kwargs["ticker_head"] else: ticker_head = "ED" ta_output_dir = dn.get_dated_directory_extension(folder_date=as_of_date, ext="ta") file_name = ta_output_dir + "/" + ticker_head + "_interest_curve.pkl" # print('as_of_date: ' + str(as_of_date) + ', date_to: ' + str(date_to)) if os.path.isfile(file_name): price_frame = pd.read_pickle(file_name) if (not os.path.isfile(file_name)) or price_frame.empty: price_frame = gfp.get_futures_price_preloaded(ticker_head=ticker_head, settle_date=as_of_date) price_frame = price_frame[price_frame["close_price"].notnull()] price_frame.sort("tr_dte", ascending=True, inplace=True) price_frame["exp_date"] = [exp.get_futures_expiration(x) for x in price_frame["ticker"]] price_frame["implied_rate"] = 100 - price_frame["close_price"] price_frame.to_pickle(file_name) if price_frame.empty: return { "rate_output": np.NaN, "price_frame": pd.DataFrame(columns=["ticker", "cal_dte", "exp_date", "implied_rate"]), } datetime_to = cu.convert_doubledate_2datetime(date_to) datetime_from = cu.convert_doubledate_2datetime(date_from) price_frame_first = price_frame[price_frame["exp_date"] <= datetime_from] price_frame_middle = price_frame[ (price_frame["exp_date"] > datetime_from) & (price_frame["exp_date"] < datetime_to) ] if price_frame_middle.empty: if not price_frame_first.empty: rate_output = price_frame_first["implied_rate"].iloc[-1] / 100 else: rate_output = price_frame["implied_rate"].iloc[0] / 100 return { "rate_output": rate_output, "price_frame": price_frame[["ticker", "cal_dte", "exp_date", "implied_rate"]], } if price_frame_first.empty: first_rate = price_frame_middle["implied_rate"].iloc[0] first_period = (price_frame_middle["exp_date"].iloc[0].to_datetime() - datetime_from).days else: first_rate = price_frame_first["implied_rate"].iloc[-1] first_period = (price_frame_middle["exp_date"].iloc[0].to_datetime() - datetime_from).days last_rate = price_frame_middle["implied_rate"].iloc[-1] last_period = (datetime_to - price_frame_middle["exp_date"].iloc[-1].to_datetime()).days middle_discount = [ 1 + ( price_frame_middle["implied_rate"].iloc[x] * (price_frame_middle["cal_dte"].iloc[x + 1] - price_frame_middle["cal_dte"].iloc[x]) / 36500 ) for x in range(len(price_frame_middle.index) - 1) ] total_discount = ( np.prod(np.array(middle_discount)) * (1 + (first_rate * first_period / 36500)) * (1 + (last_rate * last_period / 36500)) ) total_period = ( (price_frame_middle["cal_dte"].iloc[-1] - price_frame_middle["cal_dte"].iloc[0]) + first_period + last_period ) rate_output = (total_discount - 1) * 365 / total_period return {"rate_output": rate_output, "price_frame": price_frame[["ticker", "cal_dte", "exp_date", "implied_rate"]]}
def get_scv_signals(**kwargs): ticker = kwargs['ticker'] date_to = kwargs['date_to'] con = msu.get_my_sql_connection(**kwargs) 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 [cmi.get_contract_specs(ticker)['ticker_head']]} aligned_indicators_output = ops.get_aligned_option_indicators(ticker_list=[ticker], settle_date=date_to, con=con) if not aligned_indicators_output['success']: return {'downside': np.NaN, 'upside': np.NaN, 'theta': np.NaN, 'realized_vol_forecast': np.NaN, 'real_vol20_current': np.NaN, 'imp_vol': np.NaN, 'imp_vol_premium': np.NaN, 'q': np.NaN} hist = aligned_indicators_output['hist'] current = aligned_indicators_output['current'] vcs_output = vcs.generate_vcs_sheet_4date(date_to=date_to,con=con) if 'con' not in kwargs.keys(): con.close() clean_indx = hist['c1']['profit5'].notnull() clean_data = hist[clean_indx] if clean_data.empty: downside = np.NaN upside = np.NaN else: last_available_align_date = clean_data.index[-1] clean_data = clean_data[clean_data.index >= last_available_align_date-dt.timedelta(5*365)] profit5 = clean_data['c1']['profit5'] percentile_vector = stats.get_number_from_quantile(y=profit5.values, quantile_list=[1, 15, 85, 99], clean_num_obs=max(100, round(3*len(profit5.values)/4))) downside = (percentile_vector[0]+percentile_vector[1])/2 upside = (percentile_vector[2]+percentile_vector[3])/2 realized_vol_output = rvue.forecast_realized_vol_until_expiration(ticker=ticker, futures_data_dictionary=futures_data_dictionary, date_to=date_to) realized_vol_forecast = realized_vol_output['realized_vol_forecast'] real_vol20_current = realized_vol_output['real_vol20_current'] imp_vol = current['imp_vol'][0] imp_vol_premium = 100*(imp_vol-realized_vol_forecast)/imp_vol q = np.NaN if vcs_output['success']: vcs_pairs = vcs_output['vcs_pairs'] selected_pairs = vcs_pairs[vcs_pairs['ticker2'] == ticker] if not selected_pairs.empty: q = 100-selected_pairs['Q'].mean() return {'downside': downside, 'upside': upside, 'theta': current['theta'][0], 'realized_vol_forecast': realized_vol_forecast, 'real_vol20_current': real_vol20_current, 'imp_vol': imp_vol, 'imp_vol_premium': imp_vol_premium, 'q': q}
def get_strategy_pnl_4day(**kwargs): alias = kwargs['alias'] pnl_date = kwargs['pnl_date'] #print(pnl_date) pnl_datetime = cu.convert_doubledate_2datetime(pnl_date) con = msu.get_my_sql_connection(**kwargs) if 'trades_frame' in kwargs.keys(): trades_frame = kwargs['trades_frame'] ticker_head_list = [cmi.get_contract_specs(x)['ticker_head'] for x in trades_frame['ticker']] else: trades_frame = ts.get_trades_4strategy_alias(alias=alias,con=con) ticker_head_list = [cmi.get_contract_specs(x)['ticker_head'] for x in trades_frame['ticker']] trades_frame['contract_multiplier'] = [cmi.contract_multiplier[x] for x in ticker_head_list] trades_frame['t_cost'] = [cmi.t_cost[x] for x in ticker_head_list] trades_frame['ticker_head'] = ticker_head_list if 'futures_data_dictionary' in kwargs.keys(): futures_data_dictionary = kwargs['futures_data_dictionary'] else: unique_ticker_head_list = list(set(ticker_head_list)) futures_data_dictionary = {x: gfp.get_futures_price_preloaded(ticker_head=x) for x in unique_ticker_head_list} pnl_date_1 = exp.doubledate_shift_bus_days(double_date=pnl_date) underlying_frame = trades_frame[trades_frame['instrument'] == 'F'] option_frame = trades_frame[trades_frame['instrument'] == 'O'] futures_price_out_1 = [gfp.get_futures_price_preloaded(ticker=x, futures_data_dictionary=futures_data_dictionary, settle_date=pnl_date_1) for x in underlying_frame['ticker']] futures_price_out = [gfp.get_futures_price_preloaded(ticker=x, futures_data_dictionary=futures_data_dictionary, settle_date=pnl_date) for x in underlying_frame['ticker']] underlying_frame['price_1'] = [np.NaN if x.empty else x['close_price'].values[0] for x in futures_price_out_1] underlying_frame['price'] = [np.NaN if x.empty else x['close_price'].values[0] for x in futures_price_out] #underlying_frame['price_1'] = [gfp.get_futures_price_preloaded(ticker=x, # futures_data_dictionary=futures_data_dictionary, # settle_date=pnl_date_1)['close_price'].values[0] for x in underlying_frame['ticker']] #underlying_frame['price'] = [gfp.get_futures_price_preloaded(ticker=x, # futures_data_dictionary=futures_data_dictionary, # settle_date=pnl_date)['close_price'].values[0] for x in underlying_frame['ticker']] option_frame['price_1'] = [gop.get_options_price_from_db(ticker=option_frame['ticker'].iloc[x], strike=option_frame['strike_price'].iloc[x], option_type=option_frame['option_type'].iloc[x], con=con,settle_date=pnl_date_1, return_nan_if_emptyQ = True)['close_price'].values[0] for x in range(len(option_frame.index))] option_frame['price'] = [gop.get_options_price_from_db(ticker=option_frame['ticker'].iloc[x], strike=option_frame['strike_price'].iloc[x], option_type=option_frame['option_type'].iloc[x], con=con,settle_date=pnl_date, return_nan_if_emptyQ = True)['close_price'].values[0] for x in range(len(option_frame.index))] trades_frame = pd.concat([option_frame, underlying_frame]) position_frame = trades_frame[trades_frame['trade_date'] < pnl_datetime] intraday_frame = trades_frame[trades_frame['trade_date'] == pnl_datetime] position_pnl_per_ticker = pd.DataFrame(columns=['ticker','pnl_position']) intraday_pnl_per_ticker = pd.DataFrame(columns=['ticker','pnl_intraday']) position_pnl_per_tickerhead = pd.DataFrame(columns=['ticker_head','pnl_position']) intraday_pnl_per_tickerhead = pd.DataFrame(columns=['ticker_head','pnl_intraday']) if len(position_frame) == 0: position_pnl = 0 else: position_frame['pnl'] = position_frame['contract_multiplier']*\ position_frame['trade_quantity']*\ (position_frame['price']-position_frame['price_1']) position_pnl = position_frame['pnl'].sum() position_grouped_per_ticker = position_frame.groupby('ticker') position_grouped_per_tickerhead = position_frame.groupby('ticker_head') position_pnl_per_ticker['pnl_position'] = (position_grouped_per_ticker['pnl'].sum()).values position_pnl_per_ticker['ticker'] = (position_grouped_per_ticker['ticker'].first()).values position_pnl_per_tickerhead['pnl_position'] = (position_grouped_per_tickerhead['pnl'].sum()).values position_pnl_per_tickerhead['ticker_head'] = (position_grouped_per_tickerhead['ticker_head'].first()).values if len(intraday_frame) == 0: intraday_pnl = 0 t_cost = 0 else: intraday_frame['pnl'] = intraday_frame['contract_multiplier']*\ intraday_frame['trade_quantity']*\ (intraday_frame['price']-intraday_frame['trade_price']) intraday_frame['pnl_wtcost'] = intraday_frame['pnl']-abs(intraday_frame['trade_quantity']*intraday_frame['t_cost']) intraday_pnl = intraday_frame['pnl'].sum() t_cost = (abs(intraday_frame['trade_quantity']*intraday_frame['t_cost'])).sum() intraday_grouped_per_ticker = intraday_frame.groupby('ticker') intraday_grouped_per_tickerhead = intraday_frame.groupby('ticker_head') intraday_pnl_per_ticker['pnl_intraday'] = (intraday_grouped_per_ticker['pnl_wtcost'].sum()).values intraday_pnl_per_ticker['ticker'] = (intraday_grouped_per_ticker['ticker'].first()).values intraday_pnl_per_tickerhead['pnl_intraday'] = (intraday_grouped_per_tickerhead['pnl_wtcost'].sum()).values intraday_pnl_per_tickerhead['ticker_head'] = (intraday_grouped_per_tickerhead['ticker_head'].first()).values pnl_per_ticker = pd.merge(position_pnl_per_ticker,intraday_pnl_per_ticker,how='outer',on='ticker') intraday_zero_indx = [x not in intraday_pnl_per_ticker['ticker'].values for x in pnl_per_ticker['ticker']] position_zero_indx = [x not in position_pnl_per_ticker['ticker'].values for x in pnl_per_ticker['ticker']] pnl_per_ticker['pnl_position'][position_zero_indx] = 0 pnl_per_ticker['pnl_intraday'][intraday_zero_indx] = 0 pnl_per_ticker['pnl_total'] = pnl_per_ticker['pnl_position']+pnl_per_ticker['pnl_intraday'] pnl_per_ticker.set_index('ticker', drop=True, inplace=True) pnl_per_tickerhead = pd.merge(position_pnl_per_tickerhead,intraday_pnl_per_tickerhead,how='outer',on='ticker_head') intraday_zero_indx = [x not in intraday_pnl_per_tickerhead['ticker_head'].values for x in pnl_per_tickerhead['ticker_head']] position_zero_indx = [x not in position_pnl_per_tickerhead['ticker_head'].values for x in pnl_per_tickerhead['ticker_head']] pnl_per_tickerhead['pnl_position'][position_zero_indx] = 0 pnl_per_tickerhead['pnl_intraday'][intraday_zero_indx] = 0 pnl_per_tickerhead['pnl_total'] = pnl_per_tickerhead['pnl_position']+pnl_per_tickerhead['pnl_intraday'] pnl_per_tickerhead.set_index('ticker_head', drop=True, inplace=True) if 'con' not in kwargs.keys(): con.close() return {'total_pnl': int(position_pnl+intraday_pnl - t_cost), 'position_pnl': int(position_pnl), 'intraday_pnl': int(intraday_pnl), 't_cost': int(t_cost), 'pnl_per_ticker': pnl_per_ticker, 'pnl_per_tickerhead':pnl_per_tickerhead}
def get_strategy_pnl_4day(**kwargs): alias = kwargs['alias'] pnl_date = kwargs['pnl_date'] if 'shift_in_days' in kwargs.keys(): shift_in_days = kwargs['shift_in_days'] else: shift_in_days = 1 if 'broker' in kwargs.keys(): broker = kwargs['broker'] else: broker = 'abn' #print(pnl_date) pnl_datetime = cu.convert_doubledate_2datetime(pnl_date) con = msu.get_my_sql_connection(**kwargs) if 'trades_frame' in kwargs.keys(): trades_frame = kwargs['trades_frame'] ticker_head_list = [ cmi.get_contract_specs(x)['ticker_head'] for x in trades_frame['ticker'] ] else: trades_frame = ts.get_trades_4strategy_alias(alias=alias, con=con) ticker_head_list = [ cmi.get_contract_specs(x)['ticker_head'] for x in trades_frame['ticker'] ] trades_frame['contract_multiplier'] = [ cmi.contract_multiplier[x] for x in ticker_head_list ] trades_frame['t_cost'] = [ cmi.get_t_cost(ticker_head=x, broker=broker) for x in ticker_head_list ] trades_frame['ticker_head'] = ticker_head_list option_indx = trades_frame['instrument'] == 'O' trades_frame['generalized_ticker'] = trades_frame['ticker'] trades_frame['generalized_ticker'][option_indx] = trades_frame['ticker'][option_indx] + '-' + \ trades_frame['option_type'][option_indx] + '-' + \ trades_frame['strike_price'][option_indx].astype(str) position_frame_aux = trades_frame[ trades_frame['trade_date'] < pnl_datetime] intraday_frame_aux = trades_frame[trades_frame['trade_date'] == pnl_datetime] grouped = position_frame_aux.groupby(['generalized_ticker']) net_position = pd.DataFrame() net_position['qty'] = grouped['trade_quantity'].sum() net_position['generalized_ticker'] = grouped['generalized_ticker'].first() net_position = net_position[abs(net_position['qty']) > 0.1] useful_generalized_ticker_list = list( set(net_position['generalized_ticker'].values) | set(intraday_frame_aux['generalized_ticker'].unique())) trades_frame = trades_frame[trades_frame['generalized_ticker'].isin( useful_generalized_ticker_list)] if 'futures_data_dictionary' in kwargs.keys(): futures_data_dictionary = kwargs['futures_data_dictionary'] else: unique_ticker_head_list = list(set(ticker_head_list)) futures_data_dictionary = { x: gfp.get_futures_price_preloaded(ticker_head=x) for x in unique_ticker_head_list } pnl_date_1 = exp.doubledate_shift_bus_days(double_date=pnl_date, shift_in_days=shift_in_days) underlying_frame = trades_frame[trades_frame['instrument'] == 'F'] option_frame = trades_frame[trades_frame['instrument'] == 'O'] futures_price_out_1 = [ gfp.get_futures_price_preloaded( ticker=x, futures_data_dictionary=futures_data_dictionary, settle_date=pnl_date_1) for x in underlying_frame['ticker'] ] futures_price_out = [ gfp.get_futures_price_preloaded( ticker=x, futures_data_dictionary=futures_data_dictionary, settle_date=pnl_date) for x in underlying_frame['ticker'] ] underlying_frame['price_1'] = [ np.NaN if x.empty else x['close_price'].values[0] for x in futures_price_out_1 ] underlying_frame['price'] = [ np.NaN if x.empty else x['close_price'].values[0] for x in futures_price_out ] #underlying_frame['price_1'] = [gfp.get_futures_price_preloaded(ticker=x, # futures_data_dictionary=futures_data_dictionary, # settle_date=pnl_date_1)['close_price'].values[0] for x in underlying_frame['ticker']] #underlying_frame['price'] = [gfp.get_futures_price_preloaded(ticker=x, # futures_data_dictionary=futures_data_dictionary, # settle_date=pnl_date)['close_price'].values[0] for x in underlying_frame['ticker']] option_frame['price_1'] = [ gop.get_options_price_from_db( ticker=option_frame['ticker'].iloc[x], strike=option_frame['strike_price'].iloc[x], option_type=option_frame['option_type'].iloc[x], con=con, settle_date=pnl_date_1, return_nan_if_emptyQ=True)['close_price'].values[0] for x in range(len(option_frame.index)) ] option_frame['price'] = [ gop.get_options_price_from_db( ticker=option_frame['ticker'].iloc[x], strike=option_frame['strike_price'].iloc[x], option_type=option_frame['option_type'].iloc[x], con=con, settle_date=pnl_date, return_nan_if_emptyQ=True)['close_price'].values[0] for x in range(len(option_frame.index)) ] trades_frame = pd.concat([option_frame, underlying_frame]) position_frame = trades_frame[trades_frame['trade_date'] < pnl_datetime] nan_price_q = position_frame['price'].isnull().values.any() intraday_frame = trades_frame[trades_frame['trade_date'] == pnl_datetime] position_pnl_per_ticker = pd.DataFrame(columns=['ticker', 'pnl_position']) intraday_pnl_per_ticker = pd.DataFrame(columns=['ticker', 'pnl_intraday']) position_pnl_per_tickerhead = pd.DataFrame( columns=['ticker_head', 'pnl_position']) intraday_pnl_per_tickerhead = pd.DataFrame( columns=['ticker_head', 'pnl_intraday']) if len(position_frame) == 0: position_pnl = 0 else: position_frame['pnl'] = position_frame['contract_multiplier']*\ position_frame['trade_quantity']*\ (position_frame['price']-position_frame['price_1']) position_pnl = position_frame['pnl'].sum() position_grouped_per_ticker = position_frame.groupby('ticker') position_grouped_per_tickerhead = position_frame.groupby('ticker_head') position_pnl_per_ticker['pnl_position'] = ( position_grouped_per_ticker['pnl'].sum()).values position_pnl_per_ticker['ticker'] = ( position_grouped_per_ticker['ticker'].first()).values position_pnl_per_tickerhead['pnl_position'] = ( position_grouped_per_tickerhead['pnl'].sum()).values position_pnl_per_tickerhead['ticker_head'] = ( position_grouped_per_tickerhead['ticker_head'].first()).values if len(intraday_frame) == 0: intraday_pnl = 0 t_cost = 0 else: intraday_frame['pnl'] = intraday_frame['contract_multiplier']*\ intraday_frame['trade_quantity']*\ (intraday_frame['price']-intraday_frame['trade_price']) intraday_frame['pnl_wtcost'] = intraday_frame['pnl'] - abs( intraday_frame['trade_quantity'] * intraday_frame['t_cost']) intraday_pnl = intraday_frame['pnl'].sum() t_cost = (abs(intraday_frame['trade_quantity'] * intraday_frame['t_cost'])).sum() intraday_grouped_per_ticker = intraday_frame.groupby('ticker') intraday_grouped_per_tickerhead = intraday_frame.groupby('ticker_head') intraday_pnl_per_ticker['pnl_intraday'] = ( intraday_grouped_per_ticker['pnl_wtcost'].sum()).values intraday_pnl_per_ticker['ticker'] = ( intraday_grouped_per_ticker['ticker'].first()).values intraday_pnl_per_tickerhead['pnl_intraday'] = ( intraday_grouped_per_tickerhead['pnl_wtcost'].sum()).values intraday_pnl_per_tickerhead['ticker_head'] = ( intraday_grouped_per_tickerhead['ticker_head'].first()).values pnl_per_ticker = pd.merge(position_pnl_per_ticker, intraday_pnl_per_ticker, how='outer', on='ticker') intraday_zero_indx = [ x not in intraday_pnl_per_ticker['ticker'].values for x in pnl_per_ticker['ticker'] ] position_zero_indx = [ x not in position_pnl_per_ticker['ticker'].values for x in pnl_per_ticker['ticker'] ] pnl_per_ticker['pnl_position'][position_zero_indx] = 0 pnl_per_ticker['pnl_intraday'][intraday_zero_indx] = 0 pnl_per_ticker['pnl_total'] = pnl_per_ticker[ 'pnl_position'] + pnl_per_ticker['pnl_intraday'] pnl_per_ticker.set_index('ticker', drop=True, inplace=True) pnl_per_tickerhead = pd.merge(position_pnl_per_tickerhead, intraday_pnl_per_tickerhead, how='outer', on='ticker_head') intraday_zero_indx = [ x not in intraday_pnl_per_tickerhead['ticker_head'].values for x in pnl_per_tickerhead['ticker_head'] ] position_zero_indx = [ x not in position_pnl_per_tickerhead['ticker_head'].values for x in pnl_per_tickerhead['ticker_head'] ] pnl_per_tickerhead['pnl_position'][position_zero_indx] = 0 pnl_per_tickerhead['pnl_intraday'][intraday_zero_indx] = 0 pnl_per_tickerhead['pnl_total'] = pnl_per_tickerhead[ 'pnl_position'] + pnl_per_tickerhead['pnl_intraday'] pnl_per_tickerhead.set_index('ticker_head', drop=True, inplace=True) if 'con' not in kwargs.keys(): con.close() return { 'total_pnl': int(position_pnl + intraday_pnl - t_cost), 'position_pnl': int(position_pnl), 'intraday_pnl': int(intraday_pnl), 't_cost': int(t_cost), 'nan_price_q': nan_price_q, 'pnl_per_ticker': pnl_per_ticker, 'pnl_per_tickerhead': pnl_per_tickerhead }
def get_ics_signals(**kwargs): ticker = kwargs['ticker'] #print(ticker) date_to = kwargs['date_to'] con = msu.get_my_sql_connection(**kwargs) ticker_list = ticker.split('-') #print(ticker_list) ticker_head_list = [ cmi.get_contract_specs(x)['ticker_head'] for x in ticker_list ] ticker_class = cmi.ticker_class[ticker_head_list[0]] 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 list(set(ticker_head_list)) } if 'datetime5_years_ago' in kwargs.keys(): datetime5_years_ago = kwargs['datetime5_years_ago'] else: date5_years_ago = cu.doubledate_shift(date_to, 5 * 365) datetime5_years_ago = cu.convert_doubledate_2datetime(date5_years_ago) if 'num_days_back_4intraday' in kwargs.keys(): num_days_back_4intraday = kwargs['num_days_back_4intraday'] else: num_days_back_4intraday = 5 tr_dte_list = [ exp.get_days2_expiration(ticker=x, date_to=date_to, instrument='futures', con=con)['tr_dte'] for x in ticker_list ] amcb_output = [ opUtil.get_aggregation_method_contracts_back(cmi.get_contract_specs(x)) for x in ticker_list ] aggregation_method = max([x['aggregation_method'] for x in amcb_output]) contracts_back = min([x['contracts_back'] for x in amcb_output]) contract_multiplier = cmi.contract_multiplier[ticker_head_list[0]] aligned_output = opUtil.get_aligned_futures_data( contract_list=ticker_list, tr_dte_list=tr_dte_list, aggregation_method=aggregation_method, contracts_back=contracts_back, date_to=date_to, futures_data_dictionary=futures_data_dictionary, use_last_as_current=True) aligned_data = aligned_output['aligned_data'] last5_years_indx = aligned_data['settle_date'] >= datetime5_years_ago data_last5_years = aligned_data[last5_years_indx] data_last5_years['spread_pnl_1'] = aligned_data['c1'][ 'change_1'] - aligned_data['c2']['change_1'] percentile_vector = stats.get_number_from_quantile( y=data_last5_years['spread_pnl_1'].values, quantile_list=[1, 15, 85, 99], clean_num_obs=max(100, round(3 * len(data_last5_years.index) / 4))) downside = contract_multiplier * (percentile_vector[0] + percentile_vector[1]) / 2 upside = contract_multiplier * (percentile_vector[2] + percentile_vector[3]) / 2 date_list = [ exp.doubledate_shift_bus_days(double_date=date_to, shift_in_days=x) for x in reversed(range(1, num_days_back_4intraday)) ] date_list.append(date_to) intraday_data = opUtil.get_aligned_futures_data_intraday( contract_list=[ticker], date_list=date_list) 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()) end_hour = cmi.last_trade_hour_minute[ticker_head_list[0]] start_hour = cmi.first_trade_hour_minute[ticker_head_list[0]] if ticker_class == 'Ag': start_hour1 = dt.time(0, 45, 0, 0) end_hour1 = dt.time(7, 45, 0, 0) selection_indx = [ x for x in range(len(intraday_data.index)) if ((intraday_data['time_stamp'].iloc[x].time() < end_hour1) and (intraday_data['time_stamp'].iloc[x].time() >= start_hour1)) or ((intraday_data['time_stamp'].iloc[x].time() < end_hour) and (intraday_data['time_stamp'].iloc[x].time() >= start_hour)) ] else: 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_mean5 = np.nan intraday_std5 = np.nan intraday_mean2 = np.nan intraday_std2 = np.nan intraday_mean1 = np.nan intraday_std1 = np.nan if len(intraday_data.index) > 0: intraday_data['mid_p'] = (intraday_data['c1']['best_bid_p'] + intraday_data['c1']['best_ask_p']) / 2 intraday_mean5 = intraday_data['mid_p'].mean() intraday_std5 = intraday_data['mid_p'].std() intraday_data_last2days = intraday_data[ intraday_data['settle_date'] >= cu.convert_doubledate_2datetime( date_list[-2]).date()] intraday_data_yesterday = intraday_data[ intraday_data['settle_date'] == cu.convert_doubledate_2datetime( date_list[-1]).date()] intraday_mean2 = intraday_data_last2days['mid_p'].mean() intraday_std2 = intraday_data_last2days['mid_p'].std() intraday_mean1 = intraday_data_yesterday['mid_p'].mean() intraday_std1 = intraday_data_yesterday['mid_p'].std() if 'con' not in kwargs.keys(): con.close() return { 'downside': downside, 'upside': upside, 'front_tr_dte': tr_dte_list[0], 'intraday_mean5': intraday_mean5, 'intraday_std5': intraday_std5, 'intraday_mean2': intraday_mean2, 'intraday_std2': intraday_std2, 'intraday_mean1': intraday_mean1, 'intraday_std1': intraday_std1 }
def get_strategy_pnl(**kwargs): alias = kwargs['alias'] con = msu.get_my_sql_connection(**kwargs) strategy_info = ts.get_strategy_info_from_alias(alias=alias, con=con) if 'as_of_date' in kwargs.keys(): as_of_date = kwargs['as_of_date'] else: as_of_date = exp.doubledate_shift_bus_days() if 'broker' in kwargs.keys(): broker = kwargs['broker'] else: broker = 'abn' open_date = int(strategy_info['open_date'].strftime('%Y%m%d')) #open_date = 20160920 close_date = int(strategy_info['close_date'].strftime('%Y%m%d')) if close_date > as_of_date: close_date = as_of_date bus_day_list = exp.get_bus_day_list(date_from=open_date, date_to=close_date) trades_frame = ts.get_trades_4strategy_alias(alias=alias, con=con) if sum(trades_frame['instrument'] == 'S') > 0: stock_strategy_Q = True else: stock_strategy_Q = False if stock_strategy_Q: return { 'pnl_frame': pd.DataFrame(), 'daily_pnl': np.nan, 'total_pnl': np.nan } unique_ticker_list = trades_frame['ticker'].unique() stock_data_dictionary = { x: gsp.get_stock_price_preloaded(ticker=x) for x in unique_ticker_list } trades_frame['t_cost'] = [ smi.get_ib_t_cost(price=trades_frame['trade_price'].iloc[x], quantity=trades_frame['trade_quantity'].iloc[x]) for x in range(len(trades_frame.index)) ] pnl_path = [ get_stock_strategy_pnl_4day( alias=alias, pnl_date=x, con=con, trades_frame=trades_frame, stock_data_dictionary=stock_data_dictionary) for x in bus_day_list ] nan_price_q_list = [x['nan_price_q'] for x in pnl_path] good_price_q_list = [not i for i in nan_price_q_list] bus_day_after_nan_list = [ bus_day_list[x + 1] for x in range(len(bus_day_list) - 1) if nan_price_q_list[x] ] pnl_path = [ pnl_path[x] for x in range(len(pnl_path)) if good_price_q_list[x] ] bus_day_list = [ bus_day_list[x] for x in range(len(bus_day_list)) if good_price_q_list[x] ] # print(bus_day_list) # print(bus_day_after_nan_list) if len(bus_day_after_nan_list) > 0: pnl_path_after_nan = [ get_stock_strategy_pnl_4day( alias=alias, pnl_date=x, con=con, trades_frame=trades_frame, broker=broker, shift_in_days=2, stock_data_dictionary=stock_data_dictionary) for x in bus_day_after_nan_list ] for i in range(len(bus_day_after_nan_list)): if bus_day_after_nan_list[i] in bus_day_list: index_val = bus_day_list.index(bus_day_after_nan_list[i]) pnl_path[index_val] = pnl_path_after_nan[i] pnl_frame = pd.DataFrame(pnl_path) pnl_frame['settle_date'] = bus_day_list output_dictionary = { 'pnl_frame': pnl_frame[[ 'settle_date', 'position_pnl', 'intraday_pnl', 't_cost', 'total_pnl' ]], 'daily_pnl': pnl_frame['total_pnl'].values[-1], 'total_pnl': pnl_frame['total_pnl'].sum() } else: ticker_head_list = [ cmi.get_contract_specs(x)['ticker_head'] for x in trades_frame['ticker'] ] unique_ticker_head_list = list(set(ticker_head_list)) 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 unique_ticker_head_list } trades_frame['contract_multiplier'] = [ cmi.contract_multiplier[x] for x in ticker_head_list ] trades_frame['t_cost'] = [ cmi.get_t_cost(ticker_head=x, broker=broker) for x in ticker_head_list ] pnl_path = [ get_strategy_pnl_4day( alias=alias, pnl_date=x, con=con, trades_frame=trades_frame, broker=broker, futures_data_dictionary=futures_data_dictionary) for x in bus_day_list ] nan_price_q_list = [x['nan_price_q'] for x in pnl_path] good_price_q_list = [not i for i in nan_price_q_list] bus_day_after_nan_list = [ bus_day_list[x + 1] for x in range(len(bus_day_list) - 1) if nan_price_q_list[x] ] pnl_path = [ pnl_path[x] for x in range(len(pnl_path)) if good_price_q_list[x] ] bus_day_list = [ bus_day_list[x] for x in range(len(bus_day_list)) if good_price_q_list[x] ] #print(bus_day_list) #print(bus_day_after_nan_list) if len(bus_day_after_nan_list) > 0: pnl_path_after_nan = [ get_strategy_pnl_4day( alias=alias, pnl_date=x, con=con, trades_frame=trades_frame, broker=broker, shift_in_days=2, futures_data_dictionary=futures_data_dictionary) for x in bus_day_after_nan_list ] for i in range(len(bus_day_after_nan_list)): index_val = bus_day_list.index(bus_day_after_nan_list[i]) pnl_path[index_val] = pnl_path_after_nan[i] pnl_per_tickerhead_list = [x['pnl_per_tickerhead'] for x in pnl_path] pnl_per_tickerhead = pd.concat(pnl_per_tickerhead_list, axis=1, sort=True) pnl_per_tickerhead = pnl_per_tickerhead[['pnl_total']] pnl_per_tickerhead = pnl_per_tickerhead.transpose() if len(unique_ticker_head_list) > 1: zero_indx = [[x not in y.index for y in pnl_per_tickerhead_list] for x in pnl_per_tickerhead.columns] for i in range(len(pnl_per_tickerhead.columns)): pnl_per_tickerhead.iloc[:, i][zero_indx[i]] = 0 pnl_per_tickerhead['settle_date'] = bus_day_list pnl_per_tickerhead.reset_index(inplace=True, drop=True) pnl_frame = pd.DataFrame(pnl_path) pnl_frame['settle_date'] = bus_day_list daily_index = pnl_frame['settle_date'] == as_of_date if sum(daily_index) == 0: daily_pnl = np.nan else: daily_pnl = pnl_frame['total_pnl'].values[-1] output_dictionary = { 'pnl_frame': pnl_frame[[ 'settle_date', 'position_pnl', 'intraday_pnl', 't_cost', 'total_pnl' ]], 'pnl_per_tickerhead': pnl_per_tickerhead, 'daily_pnl': daily_pnl, 'total_pnl': pnl_frame['total_pnl'].sum() } if 'con' not in kwargs.keys(): con.close() return output_dictionary
def get_results_4strategy(**kwargs): signal_input = dict() if 'futures_data_dictionary' in kwargs.keys(): signal_input['futures_data_dictionary'] = kwargs['futures_data_dictionary'] if 'date_to' in kwargs.keys(): date_to = kwargs['date_to'] else: date_to = exp.doubledate_shift_bus_days() if 'datetime5_years_ago' in kwargs.keys(): signal_input['datetime5_years_ago'] = kwargs['datetime5_years_ago'] if 'strategy_info_output' in kwargs.keys(): strategy_info_output = kwargs['strategy_info_output'] else: strategy_info_output = ts.get_strategy_info_from_alias(**kwargs) con = msu.get_my_sql_connection(**kwargs) strategy_info_dict = sc.convert_from_string_to_dictionary(string_input=strategy_info_output['description_string']) #print(kwargs['alias']) strategy_class = strategy_info_dict['strategy_class'] pnl_frame = tpm.get_daily_pnl_snapshot(as_of_date=date_to) pnl_frame = pnl_frame[pnl_frame['alias']==kwargs['alias']] strategy_position = ts.get_net_position_4strategy_alias(alias=kwargs['alias'],as_of_date=date_to) if strategy_class == 'futures_butterfly': ticker_head = cmi.get_contract_specs(strategy_info_dict['ticker1'])['ticker_head'] if not strategy_position.empty: total_contracts2trade = strategy_position['qty'].abs().sum() t_cost = cmi.t_cost[ticker_head] QF_initial = float(strategy_info_dict['QF']) z1_initial = float(strategy_info_dict['z1']) bf_signals_output = fs.get_futures_butterfly_signals(ticker_list=[strategy_info_dict['ticker1'], strategy_info_dict['ticker2'], strategy_info_dict['ticker3']], aggregation_method=int(strategy_info_dict['agg']), contracts_back=int(strategy_info_dict['cBack']), date_to=date_to,**signal_input) aligned_output = bf_signals_output['aligned_output'] current_data = aligned_output['current_data'] holding_tr_dte = int(strategy_info_dict['trDte1'])-current_data['c1']['tr_dte'] if strategy_position.empty: recommendation = 'CLOSE' elif (z1_initial>0)&(holding_tr_dte > 5) &\ (bf_signals_output['qf']<QF_initial-20)&\ (pnl_frame['total_pnl'].iloc[0] > 3*t_cost*total_contracts2trade): recommendation = 'STOP' elif (z1_initial<0)&(holding_tr_dte > 5) &\ (bf_signals_output['qf']>QF_initial+20)&\ (pnl_frame['total_pnl'].iloc[0] > 3*t_cost*total_contracts2trade): recommendation = 'STOP' elif (current_data['c1']['tr_dte'] < 35)&\ (pnl_frame['total_pnl'].iloc[0] > 3*t_cost*total_contracts2trade): recommendation = 'STOP' elif (current_data['c1']['tr_dte'] < 35)&\ (pnl_frame['total_pnl'].iloc[0] < 3*t_cost*total_contracts2trade): recommendation = 'WINDDOWN' else: recommendation = 'HOLD' result_output = {'success': True,'ticker_head': ticker_head, 'QF_initial':QF_initial,'z1_initial': z1_initial, 'QF': bf_signals_output['qf'],'z1': bf_signals_output['zscore1'], 'short_tr_dte': current_data['c1']['tr_dte'], 'holding_tr_dte': holding_tr_dte, 'second_spread_weight': bf_signals_output['second_spread_weight_1'],'recommendation': recommendation} elif strategy_class == 'spread_carry': trades4_strategy = ts.get_trades_4strategy_alias(**kwargs) grouped = trades4_strategy.groupby('ticker') net_position = pd.DataFrame() net_position['ticker'] = (grouped['ticker'].first()).values net_position['qty'] = (grouped['trade_quantity'].sum()).values net_position = net_position[net_position['qty'] != 0] net_position['ticker_head'] = [cmi.get_contract_specs(x)['ticker_head'] for x in net_position['ticker']] price_output = [gfp.get_futures_price_preloaded(ticker=x, settle_date=date_to) for x in net_position['ticker']] net_position['tr_dte'] = [x['tr_dte'].values[0] for x in price_output] results_frame = pd.DataFrame() unique_tickerhead_list = net_position['ticker_head'].unique() results_frame['tickerHead'] = unique_tickerhead_list results_frame['ticker1'] = [None]*len(unique_tickerhead_list) results_frame['ticker2'] = [None]*len(unique_tickerhead_list) results_frame['qty'] = [None]*len(unique_tickerhead_list) results_frame['pnl'] = [None]*len(unique_tickerhead_list) results_frame['downside'] = [None]*len(unique_tickerhead_list) results_frame['indicator'] = [None]*len(unique_tickerhead_list) results_frame['timeHeld'] = [None]*len(unique_tickerhead_list) results_frame['recommendation'] = [None]*len(unique_tickerhead_list) spread_carry_output = osc.generate_spread_carry_sheet_4date(report_date=date_to) spread_report = spread_carry_output['spread_report'] pnl_output = tpnl.get_strategy_pnl(**kwargs) pnl_per_tickerhead = pnl_output['pnl_per_tickerhead'] for i in range(len(unique_tickerhead_list)): net_position_per_tickerhead = net_position[net_position['ticker_head'] == unique_tickerhead_list[i]] net_position_per_tickerhead.sort('tr_dte',ascending=True,inplace=True) selected_spread = spread_report[(spread_report['ticker1'] == net_position_per_tickerhead['ticker'].values[0]) & (spread_report['ticker2'] == net_position_per_tickerhead['ticker'].values[1])] results_frame['ticker1'][i] = selected_spread['ticker1'].values[0] results_frame['ticker2'][i] = selected_spread['ticker2'].values[0] results_frame['qty'][i] = net_position_per_tickerhead['qty'].values[0] selected_trades = trades4_strategy[trades4_strategy['ticker'] == results_frame['ticker1'].values[i]] price_output = gfp.get_futures_price_preloaded(ticker=results_frame['ticker1'].values[i], settle_date=pd.to_datetime(selected_trades['trade_date'].values[0])) results_frame['timeHeld'][i] = price_output['tr_dte'].values[0]-net_position_per_tickerhead['tr_dte'].values[0] results_frame['pnl'][i] = pnl_per_tickerhead[unique_tickerhead_list[i]].sum() if unique_tickerhead_list[i] in ['CL', 'B', 'ED']: results_frame['indicator'][i] = selected_spread['reward_risk'].values[0] if results_frame['qty'][i] > 0: results_frame['recommendation'][i] = 'STOP' elif results_frame['qty'][i] < 0: if results_frame['indicator'][i] > -0.06: results_frame['recommendation'][i] = 'STOP' else: results_frame['recommendation'][i] = 'HOLD' else: results_frame['indicator'][i] = selected_spread['q_carry'].values[0] if results_frame['qty'][i] > 0: if results_frame['indicator'][i] < 19: results_frame['recommendation'][i] = 'STOP' else: results_frame['recommendation'][i] = 'HOLD' elif results_frame['qty'][i] < 0: if results_frame['indicator'][i] > -9: results_frame['recommendation'][i] = 'STOP' else: results_frame['recommendation'][i] = 'HOLD' if results_frame['qty'][i] > 0: results_frame['downside'][i] = selected_spread['downside'].values[0]*results_frame['qty'][i] else: results_frame['downside'][i] = selected_spread['upside'].values[0]*results_frame['qty'][i] return {'success': True, 'results_frame': results_frame} elif strategy_class == 'vcs': greeks_out = sg.get_greeks_4strategy_4date(alias=kwargs['alias'], as_of_date=date_to) ticker_portfolio = greeks_out['ticker_portfolio'] if ticker_portfolio.empty: min_tr_dte = np.NaN result_output = {'success': False, 'net_oev': np.NaN, 'net_theta': np.NaN, 'long_short_ratio': np.NaN, 'recommendation': 'EMPTY', 'last_adjustment_days_ago': np.NaN, 'min_tr_dte': np.NaN, 'long_oev': np.NaN, 'short_oev': np.NaN, 'favQMove': np.NaN} else: min_tr_dte = min([exp.get_days2_expiration(ticker=x,date_to=date_to,instrument='options',con=con)['tr_dte'] for x in ticker_portfolio['ticker']]) net_oev = ticker_portfolio['total_oev'].sum() net_theta = ticker_portfolio['theta'].sum() long_portfolio = ticker_portfolio[ticker_portfolio['total_oev'] > 0] short_portfolio = ticker_portfolio[ticker_portfolio['total_oev'] < 0] short_portfolio['total_oev']=abs(short_portfolio['total_oev']) long_oev = long_portfolio['total_oev'].sum() short_oev = short_portfolio['total_oev'].sum() if (not short_portfolio.empty) & (not long_portfolio.empty): long_short_ratio = 100*long_oev/short_oev long_portfolio.sort('total_oev', ascending=False, inplace=True) short_portfolio.sort('total_oev', ascending=False, inplace=True) long_ticker = long_portfolio['ticker'].iloc[0] short_ticker = short_portfolio['ticker'].iloc[0] long_contract_specs = cmi.get_contract_specs(long_ticker) short_contract_specs = cmi.get_contract_specs(short_ticker) if 12*long_contract_specs['ticker_year']+long_contract_specs['ticker_month_num'] < \ 12*short_contract_specs['ticker_year']+short_contract_specs['ticker_month_num']: front_ticker = long_ticker back_ticker = short_ticker direction = 'long' else: front_ticker = short_ticker back_ticker = long_ticker direction = 'short' if 'vcs_output' in kwargs.keys(): vcs_output = kwargs['vcs_output'] else: vcs_output = ovcs.generate_vcs_sheet_4date(date_to=date_to) vcs_pairs = vcs_output['vcs_pairs'] selected_result = vcs_pairs[(vcs_pairs['ticker1'] == front_ticker) & (vcs_pairs['ticker2'] == back_ticker)] if selected_result.empty: favQMove = np.NaN else: current_Q = selected_result['Q'].iloc[0] q_limit = of.get_vcs_filter_values(product_group=long_contract_specs['ticker_head'], filter_type='tickerHead',direction=direction,indicator='Q') if direction == 'long': favQMove = current_Q-q_limit elif direction == 'short': favQMove = q_limit-current_Q else: long_short_ratio = np.NaN favQMove = np.NaN trades_frame = ts.get_trades_4strategy_alias(**kwargs) trades_frame_options = trades_frame[trades_frame['instrument'] == 'O'] last_adjustment_days_ago = len(exp.get_bus_day_list(date_to=date_to,datetime_from=max(trades_frame_options['trade_date']).to_datetime())) if favQMove >= 10 and last_adjustment_days_ago > 10: recommendation = 'STOP-ratio normalized' elif min_tr_dte<25: recommendation = 'STOP-close to expiration' elif np.isnan(long_short_ratio): recommendation = 'STOP-not a proper calendar' else: if long_short_ratio < 80: if favQMove < 0: recommendation = 'buy_options_to_grow' else: recommendation = 'buy_options_to_shrink' elif long_short_ratio > 120: if favQMove < 0: recommendation = 'sell_options_to_grow' else: recommendation = 'sell_options_to_shrink' else: recommendation = 'HOLD' result_output = {'success': True, 'net_oev': net_oev, 'net_theta': net_theta, 'long_short_ratio': long_short_ratio, 'recommendation': recommendation, 'last_adjustment_days_ago': last_adjustment_days_ago, 'min_tr_dte': min_tr_dte, 'long_oev': long_oev, 'short_oev': short_oev, 'favQMove': favQMove} else: result_output = {'success': False} if 'con' not in kwargs.keys(): con.close() return result_output
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 get_fm_signals(**kwargs): ticker_head = kwargs['ticker_head'] date_to = kwargs['date_to'] #print(ticker_head) ticker_class = cmi.ticker_class[ticker_head] datetime_to = cu.convert_doubledate_2datetime(date_to) date5_years_ago = cu.doubledate_shift(date_to,5*365) datetime5_years_ago = cu.convert_doubledate_2datetime(date5_years_ago) data_out = gfp.get_futures_price_preloaded(ticker_head=ticker_head,settle_date_to=datetime_to) data4day = data_out[data_out['settle_date']==datetime_to] data4day = data4day[data4day['tr_dte']>=20] if len(data4day.index)<2: return {'ticker': '', 'comm_net': np.nan, 'spec_net': np.nan, 'comm_cot_index_slow': np.nan, 'comm_cot_index_fast': np.nan, 'trend_direction': np.nan,'curve_slope': np.nan, 'rsi_3': np.nan, 'rsi_7': np.nan, 'rsi_14': np.nan, 'change1': np.nan, 'change1_instant': np.nan, 'change5': np.nan, 'change10': np.nan, 'change20': np.nan, 'change1_dollar': np.nan, 'change1_instant_dollar': np.nan, 'change5_dollar': np.nan, 'change10_dollar': np.nan, 'change20_dollar': np.nan} data4day.sort_values('volume', ascending=False, inplace=True) data4day = data4day.iloc[:2] data4day.sort_values('tr_dte',ascending=True,inplace=True) ticker1 = data4day['ticker'].iloc[0] ticker2 = data4day['ticker'].iloc[1] tr_dte_list = [data4day['tr_dte'].iloc[0], data4day['tr_dte'].iloc[1]] amcb_output = opUtil.get_aggregation_method_contracts_back({'ticker_head': ticker_head, 'ticker_class': cmi.ticker_class[ticker_head]}) aggregation_method = amcb_output['aggregation_method'] contracts_back = amcb_output['contracts_back'] futures_data_dictionary = {ticker_head: data_out} aligned_output = opUtil.get_aligned_futures_data(contract_list=[ticker1,ticker2], tr_dte_list=tr_dte_list, aggregation_method=aggregation_method, contracts_back=contracts_back, date_to=date_to, futures_data_dictionary=futures_data_dictionary, use_last_as_current=False) aligned_data = aligned_output['aligned_data'] current_data = aligned_output['current_data'] yield1_current = 100*(current_data['c1']['close_price']-current_data['c2']['close_price'])/current_data['c2']['close_price'] yield1 = 100*(aligned_data['c1']['close_price']-aligned_data['c2']['close_price'])/aligned_data['c2']['close_price'] last5_years_indx = aligned_data['settle_date']>=datetime5_years_ago yield1_last5_years = yield1[last5_years_indx] curve_slope = stats.get_quantile_from_number({'x':yield1_current,'y': yield1_last5_years}) ticker_head_data = gfp.get_futures_price_preloaded(ticker_head=ticker_head) ticker_head_data = ticker_head_data[ticker_head_data['settle_date'] <= datetime_to] if ticker_class in ['Index', 'FX', 'Metal', 'Treasury', 'STIR']: merged_data = ticker_head_data[ticker_head_data['tr_dte'] >= 10] merged_data.sort_values(['settle_date', 'tr_dte'],ascending=True,inplace=True) merged_data.drop_duplicates(subset=['settle_date'], keep='first', inplace=True) merged_data['ma200'] = merged_data['close_price'].rolling(200).mean() merged_data['ma200_10'] = merged_data['ma200']-merged_data['ma200'].shift(10) else: data_out_front = ticker_head_data[ticker_head_data['tr_dte'] <= 60] data_out_front.drop_duplicates(subset=['settle_date'], keep='last', inplace=True) data_out_back = ticker_head_data[ticker_head_data['tr_dte'] > 60] data_out_back.drop_duplicates(subset=['settle_date'], keep='last', inplace=True) merged_data = pd.merge(data_out_front[['settle_date','tr_dte','close_price']],data_out_back[['tr_dte','close_price','settle_date','ticker','change_1']],how='inner',on='settle_date') merged_data['const_mat']=((merged_data['tr_dte_y']-60)*merged_data['close_price_x']+ (60-merged_data['tr_dte_x'])*merged_data['close_price_y'])/\ (merged_data['tr_dte_y']-merged_data['tr_dte_x']) merged_data['ma200'] = merged_data['const_mat'].rolling(200).mean() merged_data['ma200_10'] = merged_data['ma200']-merged_data['ma200'].shift(10) merged_data = merged_data[merged_data['settle_date']==datetime_to] if len(merged_data.index) == 0: trend_direction = np.nan elif merged_data['ma200_10'].iloc[0]>=0: trend_direction = 1 else: trend_direction = -1 ticker_data = gfp.get_futures_price_preloaded(ticker=ticker2,settle_date_to=datetime_to) ticker_data = ti.rsi(data_frame_input=ticker_data, change_field='change_1', period=3) ticker_data = ti.rsi(data_frame_input=ticker_data, change_field='change_1', period=7) ticker_data = ti.rsi(data_frame_input=ticker_data, change_field='change_1', period=14) cot_output = cot.get_cot_data(ticker_head=ticker_head, date_to=date_to) daily_noise = np.std(ticker_data['change_1'].iloc[-60:]) if len(cot_output.index)>0: if ticker_class in ['FX','STIR','Index','Treasury']: cot_output['comm_long'] = cot_output['Asset Manager Longs']+cot_output['Dealer Longs'] cot_output['comm_short'] = cot_output['Asset Manager Shorts']+cot_output['Dealer Shorts'] cot_output['comm_net'] = cot_output['comm_long']-cot_output['comm_short'] cot_output['spec_long'] = cot_output['Leveraged Funds Longs'] cot_output['spec_short'] = cot_output['Leveraged Funds Shorts'] cot_output['spec_net'] = cot_output['spec_long']-cot_output['spec_short'] else: cot_output['comm_long'] = cot_output['Producer/Merchant/Processor/User Longs']+cot_output['Swap Dealer Longs'] cot_output['comm_short'] = cot_output['Producer/Merchant/Processor/User Shorts']+cot_output['Swap Dealer Shorts'] cot_output['comm_net'] = cot_output['comm_long']-cot_output['comm_short'] cot_output['spec_long'] = cot_output['Money Manager Longs']+cot_output['Other Reportable Longs'] cot_output['spec_short'] = cot_output['Money Manager Shorts']+cot_output['Other Reportable Shorts'] cot_output['spec_net'] = cot_output['spec_long']-cot_output['spec_short'] if (datetime_to-cot_output['settle_date'].iloc[-1]).days>=10: comm_net = np.nan spec_net = np.nan else: comm_net = cot_output['comm_net'].iloc[-1] spec_net = cot_output['spec_net'].iloc[-1] comm_net_min_slow = cot_output['comm_net'].iloc[-156:].min() comm_net_max_slow = cot_output['comm_net'].iloc[-156:].max() comm_cot_index_slow = 100*(comm_net-comm_net_min_slow)/(comm_net_max_slow-comm_net_min_slow) comm_net_min_fast = cot_output['comm_net'].iloc[-52:].min() comm_net_max_fast = cot_output['comm_net'].iloc[-52:].max() comm_cot_index_fast = 100*(comm_net-comm_net_min_fast)/(comm_net_max_fast-comm_net_min_fast) else: comm_net = np.nan spec_net = np.nan comm_cot_index_slow = np.nan comm_cot_index_fast = np.nan contract_multiplier = cmi.contract_multiplier[ticker_head] return {'ticker': ticker2, 'comm_net': comm_net, 'spec_net': spec_net, 'comm_cot_index_slow': comm_cot_index_slow, 'comm_cot_index_fast': comm_cot_index_fast, 'trend_direction': trend_direction,'curve_slope': curve_slope, 'rsi_3': ticker_data['rsi_3'].iloc[-1], 'rsi_7': ticker_data['rsi_7'].iloc[-1], 'rsi_14': ticker_data['rsi_14'].iloc[-1], 'change1': ticker_data['change1'].iloc[-1]/daily_noise, 'change1_instant': ticker_data['change1_instant'].iloc[-1]/daily_noise, 'change5': ticker_data['change5'].iloc[-1]/daily_noise, 'change10': ticker_data['change10'].iloc[-1]/daily_noise, 'change20': ticker_data['change20'].iloc[-1]/daily_noise, 'change1_dollar': ticker_data['change1'].iloc[-1]*contract_multiplier, 'change1_instant_dollar': ticker_data['change1_instant'].iloc[-1]*contract_multiplier, 'change5_dollar': ticker_data['change5'].iloc[-1]*contract_multiplier, 'change10_dollar': ticker_data['change10'].iloc[-1]*contract_multiplier, 'change20_dollar': ticker_data['change20'].iloc[-1]*contract_multiplier}
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 get_cot_strategy_signals(**kwargs): ticker_head = kwargs['ticker_head'] date_to = kwargs['date_to'] target_noise = 5000 ticker_class = cmi.ticker_class[ticker_head] datetime_to = cu.convert_doubledate_2datetime(date_to) data_out = gfp.get_futures_price_preloaded(ticker_head=ticker_head) data_out = data_out[data_out['settle_date'] <= datetime_to] data_out_front = data_out[data_out['tr_dte'] <= 60] data_out_front.drop_duplicates(subset=['settle_date'], keep='last', inplace=True) data_out_back = data_out[data_out['tr_dte'] > 60] data_out_back.drop_duplicates(subset=['settle_date'], keep='last', inplace=True) merged_data = pd.merge(data_out_front[['settle_date','tr_dte','close_price']],data_out_back[['tr_dte','close_price','settle_date','ticker','change_1']],how='inner',on='settle_date') merged_data['const_mat']=((merged_data['tr_dte_y']-60)*merged_data['close_price_x']+ (60-merged_data['tr_dte_x'])*merged_data['close_price_y'])/\ (merged_data['tr_dte_y']-merged_data['tr_dte_x']) merged_data['const_mat_change_1'] = merged_data['const_mat']-merged_data['const_mat'].shift(1) merged_data['const_mat_change_10'] = merged_data['const_mat']-merged_data['const_mat'].shift(10) merged_data['const_mat_change_20'] = merged_data['const_mat']-merged_data['const_mat'].shift(20) merged_data['const_mat_change_1_std'] = pd.rolling_std(merged_data['const_mat_change_1'], window=150, min_periods=75) merged_data['const_mat_ma5'] = pd.rolling_mean(merged_data['const_mat'], window=5, min_periods=4) merged_data['const_mat_ma10'] = pd.rolling_mean(merged_data['const_mat'], window=10, min_periods=8) merged_data['const_mat_ma20'] = pd.rolling_mean(merged_data['const_mat'], window=20, min_periods=16) merged_data['const_mat_ma40'] = pd.rolling_mean(merged_data['const_mat'], window=40, min_periods=32) merged_data['const_mat_ma80'] = pd.rolling_mean(merged_data['const_mat'], window=80, min_periods=64) merged_data['const_mat_ma5spread'] = (merged_data['const_mat']-merged_data['const_mat_ma5'])/merged_data['const_mat_change_1_std'] merged_data['const_mat_ma10spread'] = (merged_data['const_mat']-merged_data['const_mat_ma10'])/merged_data['const_mat_change_1_std'] merged_data['const_mat_ma20spread'] = (merged_data['const_mat']-merged_data['const_mat_ma20'])/merged_data['const_mat_change_1_std'] merged_data['const_mat_ma40spread'] = (merged_data['const_mat']-merged_data['const_mat_ma40'])/merged_data['const_mat_change_1_std'] merged_data['const_mat_ma80spread'] = (merged_data['const_mat']-merged_data['const_mat_ma80'])/merged_data['const_mat_change_1_std'] merged_data['const_mat_change1norm'] = (merged_data['const_mat'].shift(-1)-merged_data['const_mat'])/merged_data['const_mat_change_1_std'] merged_data['const_mat_change2norm'] = (merged_data['const_mat'].shift(-2)-merged_data['const_mat'])/merged_data['const_mat_change_1_std'] merged_data['const_mat_change5norm'] = (merged_data['const_mat'].shift(-5)-merged_data['const_mat'])/merged_data['const_mat_change_1_std'] merged_data['const_mat_change10norm'] = (merged_data['const_mat'].shift(-10)-merged_data['const_mat'])/merged_data['const_mat_change_1_std'] merged_data['const_mat_change20norm'] = (merged_data['const_mat'].shift(-20)-merged_data['const_mat'])/merged_data['const_mat_change_1_std'] merged_data['const_mat_change_10_std'] = pd.rolling_std(merged_data['const_mat_change_10'], window=150, min_periods=75) merged_data['const_mat_change_20_std'] = pd.rolling_std(merged_data['const_mat_change_20'], window=150, min_periods=75) merged_data['const_mat_change_10_norm'] = merged_data['const_mat_change_10']/merged_data['const_mat_change_10_std'] merged_data['const_mat_change_20_norm'] = merged_data['const_mat_change_20']/merged_data['const_mat_change_20_std'] merged_data['const_mat_min5'] = pd.rolling_min(merged_data['const_mat'], window=5, min_periods=4) merged_data['const_mat_min10'] = pd.rolling_min(merged_data['const_mat'], window=10, min_periods=8) merged_data['const_mat_min20'] = pd.rolling_min(merged_data['const_mat'], window=20, min_periods=16) merged_data['const_mat_max5'] = pd.rolling_max(merged_data['const_mat'], window=5, min_periods=4) merged_data['const_mat_max10'] = pd.rolling_max(merged_data['const_mat'], window=10, min_periods=8) merged_data['const_mat_max20'] = pd.rolling_max(merged_data['const_mat'], window=20, min_periods=16) cot_output = cot.get_cot_data(ticker_head=ticker_head,date_to=date_to) if ticker_class in ['FX','STIR','Index','Treasury']: cot_output['comm_net'] = cot_output['Dealer Longs']-cot_output['Dealer Shorts'] cot_output['comm_long'] = cot_output['Dealer Longs'] cot_output['comm_short'] = cot_output['Dealer Shorts'] cot_output['spec_net'] = cot_output['Asset Manager Longs']-cot_output['Asset Manager Shorts']+cot_output['Leveraged Funds Longs']-cot_output['Leveraged Funds Shorts'] cot_output['spec_long'] = cot_output['Asset Manager Longs']+cot_output['Leveraged Funds Longs'] cot_output['spec_short'] = cot_output['Asset Manager Shorts']+cot_output['Leveraged Funds Shorts'] else: cot_output['comm_net'] = cot_output['Producer/Merchant/Processor/User Longs']-cot_output['Producer/Merchant/Processor/User Shorts'] cot_output['comm_long'] = cot_output['Producer/Merchant/Processor/User Longs'] cot_output['comm_short'] = cot_output['Producer/Merchant/Processor/User Shorts'] cot_output['spec_net'] = cot_output['Money Manager Longs']-cot_output['Money Manager Shorts'] cot_output['spec_long'] = cot_output['Money Manager Longs'] cot_output['spec_short'] = cot_output['Money Manager Shorts'] cot_output['spec_long_per_mean'] = pd.rolling_mean(cot_output['spec_long_per'],window=150,min_periods=75) cot_output['spec_short_per_mean'] = pd.rolling_mean(cot_output['spec_short_per'],window=150,min_periods=75) cot_output['comm_net_change_1'] = cot_output['comm_net']-cot_output['comm_net'].shift(1) cot_output['comm_net_change_2'] = cot_output['comm_net']-cot_output['comm_net'].shift(2) cot_output['comm_net_change_4'] = cot_output['comm_net']-cot_output['comm_net'].shift(4) cot_output['spec_net_change_1'] = cot_output['spec_net']-cot_output['spec_net'].shift(1) cot_output['spec_net_change_2'] = cot_output['spec_net']-cot_output['spec_net'].shift(2) cot_output['spec_net_change_4'] = cot_output['spec_net']-cot_output['spec_net'].shift(4) cot_output['comm_long_change_1'] = cot_output['comm_long']-cot_output['comm_long'].shift(1) cot_output['comm_short_change_1'] = cot_output['comm_short']-cot_output['comm_short'].shift(1) cot_output['comm_net_change_1_std'] = pd.rolling_std(cot_output['comm_net_change_1'], window=150, min_periods=75) cot_output['comm_net_change_2_std'] = pd.rolling_std(cot_output['comm_net_change_2'], window=150, min_periods=75) cot_output['comm_net_change_4_std'] = pd.rolling_std(cot_output['comm_net_change_4'], window=150, min_periods=75) cot_output['spec_net_change_1_std'] = pd.rolling_std(cot_output['spec_net_change_1'], window=150, min_periods=75) cot_output['spec_net_change_2_std'] = pd.rolling_std(cot_output['spec_net_change_2'], window=150, min_periods=75) cot_output['spec_net_change_4_std'] = pd.rolling_std(cot_output['spec_net_change_4'], window=150, min_periods=75) cot_output['comm_long_change_1_std'] = pd.rolling_std(cot_output['comm_long_change_1'], window=150, min_periods=75) cot_output['comm_short_change_1_std'] = pd.rolling_std(cot_output['comm_short_change_1'], window=150, min_periods=75) cot_output['comm_net_change_1_norm'] = cot_output['comm_net_change_1']/cot_output['comm_net_change_1_std'] cot_output['comm_net_change_2_norm'] = cot_output['comm_net_change_2']/cot_output['comm_net_change_2_std'] cot_output['comm_net_change_4_norm'] = cot_output['comm_net_change_4']/cot_output['comm_net_change_4_std'] cot_output['spec_net_change_1_norm'] = cot_output['spec_net_change_1']/cot_output['spec_net_change_1_std'] cot_output['spec_net_change_2_norm'] = cot_output['spec_net_change_2']/cot_output['spec_net_change_2_std'] cot_output['spec_net_change_4_norm'] = cot_output['spec_net_change_4']/cot_output['spec_net_change_4_std'] cot_output['comm_long_change_1_norm'] = cot_output['comm_long_change_1']/cot_output['comm_long_change_1_std'] cot_output['comm_short_change_1_norm'] = cot_output['comm_short_change_1']/cot_output['comm_short_change_1_std'] cot_output['comm_net_mean'] = pd.rolling_mean(cot_output['comm_net'],window=150,min_periods=75) cot_output['spec_net_mean'] = pd.rolling_mean(cot_output['spec_net'],window=150,min_periods=75) cot_output['comm_net_std'] = pd.rolling_std(cot_output['comm_net'],window=150,min_periods=75) cot_output['spec_net_std'] = pd.rolling_std(cot_output['spec_net'],window=150,min_periods=75) cot_output['comm_z'] = (cot_output['comm_net']-cot_output['comm_net_mean'])/cot_output['comm_net_std'] cot_output['spec_z'] = (cot_output['spec_net']-cot_output['spec_net_mean'])/cot_output['spec_net_std'] cot_output['settle_date'] = cot_output.index cot_output['settle_date'] = [x+dt.timedelta(days=3) for x in cot_output['settle_date']] combined_data = pd.merge(merged_data,cot_output,how='left',on='settle_date') combined_data['comm_net_change_1_norm'] = combined_data['comm_net_change_1_norm'].fillna(method='pad') combined_data['comm_net_change_2_norm'] = combined_data['comm_net_change_2_norm'].fillna(method='pad') combined_data['comm_net_change_4_norm'] = combined_data['comm_net_change_4_norm'].fillna(method='pad') combined_data['spec_net_change_1_norm'] = combined_data['spec_net_change_1_norm'].fillna(method='pad') combined_data['spec_net_change_2_norm'] = combined_data['spec_net_change_2_norm'].fillna(method='pad') combined_data['spec_net_change_4_norm'] = combined_data['spec_net_change_4_norm'].fillna(method='pad') combined_data['comm_z'] = combined_data['comm_z'].fillna(method='pad') combined_data['spec_z'] = combined_data['spec_z'].fillna(method='pad') position = 0 position_list = [] entry_index_list = [] exit_index_list = [] entry_price_list = [] exit_price_list = [] for i in range(len(combined_data.index)): spec_change1_signal = combined_data['spec_net_change_1_norm'].iloc[i] spec_change4_signal = combined_data['spec_net_change_4_norm'].iloc[i] spec_z_signal = combined_data['spec_z'].iloc[i] price_i = combined_data['const_mat'].iloc[i] min_10 = combined_data['const_mat_min10'].iloc[i] max_10 = combined_data['const_mat_max10'].iloc[i] min_20 = combined_data['const_mat_min20'].iloc[i] max_20 = combined_data['const_mat_max20'].iloc[i] const_mat_change_10_norm = combined_data['const_mat_change_10_norm'].iloc[i] const_mat_change_20_norm = combined_data['const_mat_change_20_norm'].iloc[i] if i == len(combined_data.index)-1: if position != 0: exit_index_list.append(i) exit_price_list.append(price_i) break price_i1 = combined_data['const_mat'].iloc[i+1] if (position == 0) and (spec_z_signal>0.5) and (price_i==min_10): position = 1 position_list.append(position) entry_index_list.append(i) entry_price_list.append(price_i1) elif (position == 0) and (spec_z_signal<-0.5) and (price_i==max_10): position = -1 position_list.append(position) entry_index_list.append(i) entry_price_list.append(price_i1) elif (position == 1) and ((price_i==min_20)): position = 0 exit_index_list.append(i) exit_price_list.append(price_i1) elif (position == -1) and ((price_i==max_20)): position = 0 exit_index_list.append(i) exit_price_list.append(price_i1) return {'combined_data': combined_data}
def get_intraday_spread_signals(**kwargs): ticker_list = kwargs['ticker_list'] date_to = kwargs['date_to'] #print(ticker_list) 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 ] ticker_class_list = [cmi.ticker_class[x] for x in ticker_head_list] #print('-'.join(ticker_list)) if 'tr_dte_list' in kwargs.keys(): tr_dte_list = kwargs['tr_dte_list'] else: tr_dte_list = [ exp.get_days2_expiration(ticker=x, date_to=date_to, instrument='futures')['tr_dte'] for x in ticker_list ] if 'aggregation_method' in kwargs.keys( ) and 'contracts_back' in kwargs.keys(): aggregation_method = kwargs['aggregation_method'] contracts_back = kwargs['contracts_back'] else: amcb_output = [ opUtil.get_aggregation_method_contracts_back( cmi.get_contract_specs(x)) for x in ticker_list ] aggregation_method = max( [x['aggregation_method'] for x in amcb_output]) contracts_back = min([x['contracts_back'] for x in amcb_output]) 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 list(set(ticker_head_list)) } if 'use_last_as_current' in kwargs.keys(): use_last_as_current = kwargs['use_last_as_current'] else: use_last_as_current = True if 'datetime5_years_ago' in kwargs.keys(): datetime5_years_ago = kwargs['datetime5_years_ago'] else: date5_years_ago = cu.doubledate_shift(date_to, 5 * 365) datetime5_years_ago = cu.convert_doubledate_2datetime(date5_years_ago) if 'num_days_back_4intraday' in kwargs.keys(): num_days_back_4intraday = kwargs['num_days_back_4intraday'] else: num_days_back_4intraday = 10 contract_multiplier_list = [ cmi.contract_multiplier[x] for x in ticker_head_list ] aligned_output = opUtil.get_aligned_futures_data( contract_list=ticker_list, tr_dte_list=tr_dte_list, aggregation_method=aggregation_method, contracts_back=contracts_back, date_to=date_to, futures_data_dictionary=futures_data_dictionary, use_last_as_current=use_last_as_current) aligned_data = aligned_output['aligned_data'] current_data = aligned_output['current_data'] if ticker_head_list in fixed_weight_future_spread_list: weights_output = sutil.get_spread_weights_4contract_list( ticker_head_list=ticker_head_list) spread_weights = weights_output['spread_weights'] portfolio_weights = weights_output['portfolio_weights'] else: regress_output = stats.get_regression_results({ 'x': aligned_data['c2']['change_1'][-60:], 'y': aligned_data['c1']['change_1'][-60:] }) spread_weights = [1, -regress_output['beta']] portfolio_weights = [ 1, -regress_output['beta'] * contract_multiplier_list[0] / contract_multiplier_list[1] ] aligned_data['spread'] = 0 aligned_data['spread_pnl_1'] = 0 aligned_data['spread_pnl1'] = 0 spread_settle = 0 last5_years_indx = aligned_data['settle_date'] >= datetime5_years_ago num_contracts = len(ticker_list) for i in range(num_contracts): aligned_data['spread'] = aligned_data['spread'] + aligned_data[ 'c' + str(i + 1)]['close_price'] * spread_weights[i] spread_settle = spread_settle + current_data[ 'c' + str(i + 1)]['close_price'] * spread_weights[i] aligned_data[ 'spread_pnl_1'] = aligned_data['spread_pnl_1'] + aligned_data[ 'c' + str(i + 1)]['change_1'] * portfolio_weights[ i] * contract_multiplier_list[i] aligned_data[ 'spread_pnl1'] = aligned_data['spread_pnl1'] + aligned_data[ 'c' + str(i + 1)]['change1_instant'] * portfolio_weights[ i] * contract_multiplier_list[i] aligned_data['spread_normalized'] = aligned_data['spread'] / aligned_data[ 'c1']['close_price'] data_last5_years = aligned_data[last5_years_indx] percentile_vector = stats.get_number_from_quantile( y=data_last5_years['spread_pnl_1'].values, quantile_list=[1, 15, 85, 99], clean_num_obs=max(100, round(3 * len(data_last5_years.index) / 4))) downside = (percentile_vector[0] + percentile_vector[1]) / 2 upside = (percentile_vector[2] + percentile_vector[3]) / 2 date_list = [ exp.doubledate_shift_bus_days(double_date=date_to, shift_in_days=x) for x in reversed(range(1, num_days_back_4intraday)) ] date_list.append(date_to) intraday_data = opUtil.get_aligned_futures_data_intraday( contract_list=ticker_list, date_list=date_list) if len(intraday_data.index) == 0: return { 'downside': downside, 'upside': upside, 'intraday_data': intraday_data, 'trading_data': intraday_data, 'spread_weight': spread_weights[1], 'portfolio_weight': portfolio_weights[1], 'z': np.nan, 'recent_trend': np.nan, 'intraday_mean10': np.nan, 'intraday_std10': np.nan, 'intraday_mean5': np.nan, 'intraday_std5': np.nan, 'intraday_mean2': np.nan, 'intraday_std2': np.nan, 'intraday_mean1': np.nan, 'intraday_std1': np.nan, 'aligned_output': aligned_output, 'spread_settle': spread_settle, 'data_last5_years': data_last5_years, 'ma_spread_lowL': np.nan, 'ma_spread_highL': np.nan, 'ma_spread_low': np.nan, 'ma_spread_high': np.nan, 'intraday_sharp': np.nan } 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()) end_hour = min([cmi.last_trade_hour_minute[x] for x in ticker_head_list]) start_hour = max( [cmi.first_trade_hour_minute[x] for x in ticker_head_list]) trade_start_hour = dt.time(9, 30, 0, 0) if 'Ag' in ticker_class_list: start_hour1 = dt.time(0, 45, 0, 0) end_hour1 = dt.time(7, 45, 0, 0) selection_indx = [ x for x in range(len(intraday_data.index)) if ((intraday_data['time_stamp'].iloc[x].time() < end_hour1) and (intraday_data['time_stamp'].iloc[x].time() >= start_hour1)) or ((intraday_data['time_stamp'].iloc[x].time() < end_hour) and (intraday_data['time_stamp'].iloc[x].time() >= start_hour)) ] else: 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['spread'] = 0 for i in range(num_contracts): intraday_data[ 'c' + str(i + 1), 'mid_p'] = (intraday_data['c' + str(i + 1)]['best_bid_p'] + intraday_data['c' + str(i + 1)]['best_ask_p']) / 2 intraday_data['spread'] = intraday_data['spread'] + intraday_data[ 'c' + str(i + 1)]['mid_p'] * spread_weights[i] unique_settle_dates = intraday_data['settle_date'].unique() intraday_data['spread1'] = np.nan for i in range(len(unique_settle_dates) - 1): if (intraday_data['settle_date'] == unique_settle_dates[i]).sum() == \ (intraday_data['settle_date'] == unique_settle_dates[i+1]).sum(): intraday_data.loc[intraday_data['settle_date'] == unique_settle_dates[i],'spread1'] = \ intraday_data['spread'][intraday_data['settle_date'] == unique_settle_dates[i+1]].values intraday_data = intraday_data[intraday_data['settle_date'].notnull()] intraday_mean10 = intraday_data['spread'].mean() intraday_std10 = intraday_data['spread'].std() intraday_data_last5days = intraday_data[ intraday_data['settle_date'] >= cu.convert_doubledate_2datetime( date_list[-5]).date()] intraday_data_last2days = intraday_data[ intraday_data['settle_date'] >= cu.convert_doubledate_2datetime( date_list[-2]).date()] intraday_data_yesterday = intraday_data[intraday_data['settle_date'] == cu.convert_doubledate_2datetime( date_list[-1]).date()] intraday_mean5 = intraday_data_last5days['spread'].mean() intraday_std5 = intraday_data_last5days['spread'].std() intraday_mean2 = intraday_data_last2days['spread'].mean() intraday_std2 = intraday_data_last2days['spread'].std() intraday_mean1 = intraday_data_yesterday['spread'].mean() intraday_std1 = intraday_data_yesterday['spread'].std() intraday_z = (spread_settle - intraday_mean5) / intraday_std5 num_obs_intraday = len(intraday_data.index) num_obs_intraday_half = round(num_obs_intraday / 2) intraday_tail = intraday_data.tail(num_obs_intraday_half) num_positives = sum( intraday_tail['spread'] > intraday_data['spread'].mean()) num_negatives = sum( intraday_tail['spread'] < intraday_data['spread'].mean()) if num_positives + num_negatives != 0: recent_trend = 100 * (num_positives - num_negatives) / (num_positives + num_negatives) else: recent_trend = np.nan intraday_data_shifted = intraday_data.groupby('settle_date').shift(-60) intraday_data['spread_shifted'] = intraday_data_shifted['spread'] intraday_data[ 'delta60'] = intraday_data['spread_shifted'] - intraday_data['spread'] intraday_data['ewma10'] = pd.ewma(intraday_data['spread'], span=10) intraday_data['ewma50'] = pd.ewma(intraday_data['spread'], span=50) intraday_data['ewma200'] = pd.ewma(intraday_data['spread'], span=200) intraday_data['ma40'] = pd.rolling_mean(intraday_data['spread'], 40) intraday_data[ 'ewma50_spread'] = intraday_data['spread'] - intraday_data['ewma50'] intraday_data[ 'ma40_spread'] = intraday_data['spread'] - intraday_data['ma40'] selection_indx = [ x for x in range(len(intraday_data.index)) if (intraday_data['time_stamp'].iloc[x].time() > trade_start_hour) ] selected_data = intraday_data.iloc[selection_indx] selected_data['delta60Net'] = (contract_multiplier_list[0] * selected_data['delta60'] / spread_weights[0]) selected_data.reset_index(drop=True, inplace=True) selected_data['proxy_pnl'] = 0 t_cost = cmi.t_cost[ticker_head_list[0]] ma_spread_low = np.nan ma_spread_high = np.nan ma_spread_lowL = np.nan ma_spread_highL = np.nan intraday_sharp = np.nan if sum(selected_data['ma40_spread'].notnull()) > 30: quantile_list = selected_data['ma40_spread'].quantile([0.1, 0.9]) down_indx = selected_data['ma40_spread'] < quantile_list[0.1] up_indx = selected_data['ma40_spread'] > quantile_list[0.9] up_data = selected_data[up_indx] down_data = selected_data[down_indx] ma_spread_lowL = quantile_list[0.1] ma_spread_highL = quantile_list[0.9] #return {'selected_data':selected_data,'up_data':up_data,'up_indx':up_indx} selected_data.loc[up_indx, 'proxy_pnl'] = (-up_data['delta60Net'] - 2 * num_contracts * t_cost).values selected_data.loc[down_indx, 'proxy_pnl'] = (down_data['delta60Net'] - 2 * num_contracts * t_cost).values short_term_data = selected_data[ selected_data['settle_date'] >= cu.convert_doubledate_2datetime( date_list[-5]).date()] if sum(short_term_data['ma40_spread'].notnull()) > 30: quantile_list = short_term_data['ma40_spread'].quantile([0.1, 0.9]) ma_spread_low = quantile_list[0.1] ma_spread_high = quantile_list[0.9] if selected_data['proxy_pnl'].std() != 0: intraday_sharp = selected_data['proxy_pnl'].mean( ) / selected_data['proxy_pnl'].std() return { 'downside': downside, 'upside': upside, 'intraday_data': intraday_data, 'trading_data': selected_data, 'spread_weight': spread_weights[1], 'portfolio_weight': portfolio_weights[1], 'z': intraday_z, 'recent_trend': recent_trend, 'intraday_mean10': intraday_mean10, 'intraday_std10': intraday_std10, 'intraday_mean5': intraday_mean5, 'intraday_std5': intraday_std5, 'intraday_mean2': intraday_mean2, 'intraday_std2': intraday_std2, 'intraday_mean1': intraday_mean1, 'intraday_std1': intraday_std1, 'aligned_output': aligned_output, 'spread_settle': spread_settle, 'data_last5_years': data_last5_years, 'ma_spread_lowL': ma_spread_lowL, 'ma_spread_highL': ma_spread_highL, 'ma_spread_low': ma_spread_low, 'ma_spread_high': ma_spread_high, 'intraday_sharp': intraday_sharp }
def get_historical_risk_4open_strategies(**kwargs): if 'as_of_date' in kwargs.keys(): as_of_date = kwargs['as_of_date'] else: as_of_date = exp.doubledate_shift_bus_days() kwargs['as_of_date'] = as_of_date ta_output_dir = dn.get_dated_directory_extension(folder_date=as_of_date, ext='ta') if os.path.isfile(ta_output_dir + '/portfolio_risk.pkl'): with open(ta_output_dir + '/portfolio_risk.pkl','rb') as handle: portfolio_risk_output = pickle.load(handle) return portfolio_risk_output con = msu.get_my_sql_connection(**kwargs) strategy_frame = ts.get_open_strategies(**kwargs) futures_data_dictionary = {x: gfp.get_futures_price_preloaded(ticker_head=x) for x in cmi.ticker_class.keys()} strategy_risk_frame = pd.DataFrame() historical_risk_output = [get_historical_risk_4strategy(alias=x, as_of_date=as_of_date, con=con, futures_data_dictionary=futures_data_dictionary) for x in strategy_frame['alias']] if 'con' not in kwargs.keys(): con.close() strategy_risk_frame['alias'] = strategy_frame['alias'] strategy_risk_frame['downside'] = [x['downside'] for x in historical_risk_output] strategy_risk_frame.sort('downside', ascending=True, inplace=True) ticker_head_list = su.flatten_list([list(x['ticker_head_based_pnl_5_change'].keys()) for x in historical_risk_output if x['downside'] != 0]) unique_ticker_head_list = list(set(ticker_head_list)) ticker_head_aggregated_pnl_5_change = {ticker_head: sum([x['ticker_head_based_pnl_5_change'][ticker_head] for x in historical_risk_output if x['downside'] != 0 and ticker_head in x['ticker_head_based_pnl_5_change'].keys()]) for ticker_head in unique_ticker_head_list} percentile_vector = [stats.get_number_from_quantile(y=ticker_head_aggregated_pnl_5_change[ticker_head], quantile_list=[1, 15], clean_num_obs=max(100, round(3*len(ticker_head_aggregated_pnl_5_change[ticker_head].values)/4))) for ticker_head in unique_ticker_head_list] ticker_head_risk_frame = pd.DataFrame() ticker_head_risk_frame['tickerHead'] = unique_ticker_head_list ticker_head_risk_frame['downside'] = [(x[0]+x[1])/2 for x in percentile_vector] ticker_head_risk_frame.sort('downside', ascending=True, inplace=True) strategy_risk_frame['downside'] = strategy_risk_frame['downside'].round() ticker_head_risk_frame['downside'] = ticker_head_risk_frame['downside'].round() portfolio_risk_output = {'strategy_risk_frame': strategy_risk_frame, 'ticker_head_aggregated_pnl_5_change': ticker_head_aggregated_pnl_5_change, 'ticker_head_risk_frame':ticker_head_risk_frame} with open(ta_output_dir + '/portfolio_risk.pkl', 'wb') as handle: pickle.dump(portfolio_risk_output, handle) return portfolio_risk_output
def get_past_realized_vol_until_expiration(**kwargs): ticker = kwargs['ticker'] date_to = kwargs['date_to'] contract_specs_output = cmi.get_contract_specs(ticker) ticker_class = contract_specs_output['ticker_class'] ticker_head = contract_specs_output['ticker_head'] if ticker_class in ['Index', 'FX', 'Metal', 'Treasury'] or ticker_head == 'CL': contracts_back = 100 aggregation_method = 1 elif ticker_class in ['Ag', 'Livestock'] or ticker_head == 'NG': contracts_back = 20 aggregation_method = 12 con = msu.get_my_sql_connection(**kwargs) datetime_to = cu.convert_doubledate_2datetime(date_to) exp_output = exp.get_days2_expiration(ticker=ticker, con=con, instrument='options', date_to=date_to) cal_dte = exp_output['cal_dte'] expiration_datetime = exp_output['expiration_datetime'] min_num_obs_4realized_vol_2expiration = np.floor(cal_dte*0.6*250/365) expiration_date = int(expiration_datetime.strftime('%Y%m%d')) if aggregation_method == 1: additional_contracts_2request = round(cal_dte/30) + 5 else: additional_contracts_2request = 10 report_date_list = sutil.get_bus_dates_from_agg_method_and_contracts_back(ref_date=date_to, aggregation_method=aggregation_method, contracts_back=contracts_back + additional_contracts_2request, shift_bus_days=2) exp_date_list = sutil.get_bus_dates_from_agg_method_and_contracts_back(ref_date=expiration_date, aggregation_method=aggregation_method, contracts_back=contracts_back+ additional_contracts_2request) observed_real_vol_date_from = sutil.get_bus_dates_from_agg_method_and_contracts_back(ref_date=date_to, aggregation_method=aggregation_method, contracts_back=contracts_back + additional_contracts_2request, shift_bus_days=-30) observed_real_vol_date_to = sutil.get_bus_dates_from_agg_method_and_contracts_back(ref_date=date_to, aggregation_method=aggregation_method, contracts_back=contracts_back + additional_contracts_2request) if 'con' not in kwargs.keys(): con.close() data_frame_out = pd.DataFrame.from_items([('date_from', report_date_list), ('date_to', exp_date_list), ('observed_real_vol_date_from', observed_real_vol_date_from), ('observed_real_vol_date_to', observed_real_vol_date_to)]) selection_indx = data_frame_out['date_to'] < datetime_to data_frame_out = data_frame_out[selection_indx] data_frame_out = data_frame_out[:contracts_back] data_frame_out.reset_index(drop=True, inplace=True) data_frame_out['real_vol_till_expiration'] = np.NaN data_frame_out['real_vol20'] = np.NaN data_frame_out['ticker'] = None get_futures_price_input = {} if 'futures_data_dictionary' in kwargs.keys(): get_futures_price_input['futures_data_dictionary'] = kwargs['futures_data_dictionary'] if ticker_class in ['Index', 'FX', 'Metal', 'Treasury']: rolling_price = sutil.get_rolling_futures_price(ticker_head=ticker_head, **get_futures_price_input) for i in data_frame_out.index: selected_price = rolling_price[(rolling_price['settle_date'] >= data_frame_out['date_from'].loc[i])& (rolling_price['settle_date'] <= data_frame_out['date_to'].loc[i])] if len(selected_price.index) >= min_num_obs_4realized_vol_2expiration: data_frame_out['real_vol_till_expiration'].loc[i] = 100*np.sqrt(252*np.mean(np.square(selected_price['log_return']))) selected_price = rolling_price[(rolling_price['settle_date'] >= data_frame_out['observed_real_vol_date_from'].loc[i])& (rolling_price['settle_date'] <= data_frame_out['observed_real_vol_date_to'].loc[i])] data_frame_out['real_vol20'].loc[i] = 100*np.sqrt(252*np.mean(np.square(selected_price['log_return'][-20:]))) elif ticker_class in ['Ag', 'Livestock', 'Energy']: ticker_list = sutil.get_tickers_from_agg_method_and_contracts_back(ticker=ticker, aggregation_method=aggregation_method, contracts_back=contracts_back+additional_contracts_2request) ticker_list = [ticker_list[x] for x in range(len(ticker_list)) if selection_indx[x]] ticker_list = ticker_list[:contracts_back] data_frame_out['ticker'] = ticker_list for i in data_frame_out.index: ticker_data = gfp.get_futures_price_preloaded(ticker=data_frame_out['ticker'].loc[i], **get_futures_price_input) ticker_data.sort('settle_date', ascending=True, inplace=True) shifted = ticker_data.shift(1) ticker_data['log_return'] = np.log(ticker_data['close_price']/shifted['close_price']) selected_price = ticker_data[(ticker_data['settle_date'] >= data_frame_out['date_from'].loc[i])& (ticker_data['settle_date'] <= data_frame_out['date_to'].loc[i])] if len(selected_price.index) >= min_num_obs_4realized_vol_2expiration: data_frame_out['real_vol_till_expiration'].loc[i] = 100*np.sqrt(252*np.mean(np.square(selected_price['log_return']))) selected_price = ticker_data[(ticker_data['settle_date'] >= data_frame_out['observed_real_vol_date_from'].loc[i])& (ticker_data['settle_date'] <= data_frame_out['observed_real_vol_date_to'].loc[i])] data_frame_out['real_vol20'].loc[i] = 100*np.sqrt(252*np.mean(np.square(selected_price['log_return'][-20:]))) return data_frame_out
def get_ticker_list_4tickerhead(**kwargs): if 'volume_filter' in kwargs.keys(): volume_filter = kwargs['volume_filter'] else: volume_filter = 1000 ticker_head = kwargs['ticker_head'] futures_frame = gfp.get_futures_price_preloaded(**kwargs) futures_frame = futures_frame[futures_frame['volume']>=volume_filter] outright_frame = pd.DataFrame() spread_frame = pd.DataFrame() wide_spread_frame1 = pd.DataFrame() wide_spread_frame2 = pd.DataFrame() outright_frame['ticker1'] = futures_frame['ticker'] outright_frame['ticker2'] = None spread_frame['ticker1'] = futures_frame['ticker'] spread_frame['ticker2'] = futures_frame['ticker'].shift(-1) if ticker_head in ['CL', 'HO', 'RB', 'NG', 'ED']: if ticker_head == 'ED': diff = 3 else: diff = 1 spread_frame['ticker_month1'] = futures_frame['ticker_month'] spread_frame['ticker_month2'] = futures_frame['ticker_month'].shift(-1) spread_frame['ticker_year1'] = futures_frame['ticker_year'] spread_frame['ticker_year2'] = futures_frame['ticker_year'].shift(-1) spread_frame['diff'] = 12*(spread_frame['ticker_year2']-spread_frame['ticker_year1'])+\ (spread_frame['ticker_month2']-spread_frame['ticker_month1']) spread_frame = spread_frame[spread_frame['diff'] == diff] spread_frame.drop(['ticker_month1','ticker_month2','ticker_year1','ticker_year2','diff'],axis=1,inplace=True) else: spread_frame.drop(spread_frame.index[-1],inplace=True) if ticker_head == 'CL': wide_futures_frame1 = futures_frame[futures_frame['ticker_month'] % 3 == 0] wide_spread_frame1['ticker1'] = wide_futures_frame1['ticker'] wide_spread_frame1['ticker2'] = wide_futures_frame1['ticker'].shift(-1) wide_spread_frame1.drop(wide_spread_frame1.index[-1],inplace=True) wide_futures_frame2 = futures_frame[futures_frame['ticker_month'] % 6 == 0] wide_spread_frame2['ticker1'] = wide_futures_frame2['ticker'] wide_spread_frame2['ticker2'] = wide_futures_frame2['ticker'].shift(-1) wide_spread_frame2.drop(wide_spread_frame2.index[-1],inplace=True) output_frame = pd.concat([outright_frame,spread_frame,wide_spread_frame1,wide_spread_frame2]) output_frame['tickerHead'] = ticker_head return output_frame.drop_duplicates(['ticker1','ticker2'],inplace=False)