def get_portfolio_expirations(**kwargs):
con = msu.get_my_sql_connection(**kwargs)
position_frame = tpm.get_position_4portfolio(trade_date_to=kwargs["report_date"])
position_frame.reset_index(drop=True, inplace=True)
futures_indx = position_frame["instrument"] == "F"
position_frame.loc[futures_indx, "instrument"] = "futures"
position_frame.loc[~futures_indx, "instrument"] = "options"
position_frame["tr_dte"] = position_frame.apply(
lambda x: exp.get_days2_expiration(
ticker=x["ticker"], instrument=x["instrument"], date_to=kwargs["report_date"], con=con
)["tr_dte"],
axis=1,
)
position_frame["alias"] = "Portfolio"
if "con" not in kwargs.keys():
con.close()
return position_frame
def get_strategy_expiration(**kwargs):
position_frame = ts.get_net_position_4strategy_alias(**kwargs)
if position_frame.empty:
return pd.DataFrame()
con = msu.get_my_sql_connection(**kwargs)
position_frame.reset_index(drop=True, inplace=True)
futures_indx = position_frame["instrument"] == "F"
position_frame.loc[futures_indx, "instrument"] = "futures"
position_frame.loc[~futures_indx, "instrument"] = "options"
position_frame["tr_dte"] = position_frame.apply(
lambda x: exp.get_days2_expiration(
ticker=x["ticker"], instrument=x["instrument"], date_to=kwargs["as_of_date"], con=con
)["tr_dte"],
axis=1,
)
position_frame["alias"] = kwargs["alias"]
if "con" not in kwargs.keys():
con.close()
return position_frame
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_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_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)
if 'broker' in kwargs.keys():
broker = kwargs['broker']
else:
broker = 'abn'
con = msu.get_my_sql_connection(**kwargs)
strategy_info_dict = sc.convert_from_string_to_dictionary(
string_input=strategy_info_output['description_string'])
strategy_class = strategy_info_dict['strategy_class']
pnl_frame = tpm.get_daily_pnl_snapshot(as_of_date=date_to, broker=broker)
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)
if bf_signals_output['success']:
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']
success_status = True
QF = bf_signals_output['qf']
z1 = bf_signals_output['zscore1']
short_tr_dte = current_data['c1']['tr_dte']
second_spread_weight = bf_signals_output['second_spread_weight_1']
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'
else:
success_status = False
QF = np.nan
z1 = np.nan
short_tr_dte = np.nan
holding_tr_dte = np.nan
second_spread_weight = np.nan
recommendation = 'MISSING DATA'
result_output = {
'success': success_status,
'ticker_head': ticker_head,
'QF_initial': QF_initial,
'z1_initial': z1_initial,
'QF': QF,
'z1': z1,
'short_tr_dte': short_tr_dte,
'holding_tr_dte': holding_tr_dte,
'second_spread_weight': second_spread_weight,
'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'] = [
np.nan if x.empty else 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_values('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['qty'][i] = net_position_per_tickerhead[
'qty'].values[0]
if selected_spread.empty:
results_frame['ticker1'][i] = net_position_per_tickerhead[
'ticker'].values[0]
results_frame['ticker2'][i] = net_position_per_tickerhead[
'ticker'].values[1]
else:
results_frame['ticker1'][i] = selected_spread[
'ticker1'].values[0]
results_frame['ticker2'][i] = selected_spread[
'ticker2'].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']
options_position = greeks_out['options_position']
if ticker_portfolio.empty and not options_position.empty:
result_output = {
'success': False,
'net_oev': np.NaN,
'net_theta': np.NaN,
'long_short_ratio': np.NaN,
'recommendation': 'MISSING DATA',
'last_adjustment_days_ago': np.NaN,
'min_tr_dte': np.NaN,
'long_oev': np.NaN,
'short_oev': np.NaN,
'favQMove': np.NaN
}
elif ticker_portfolio.empty and options_position.empty:
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_values('total_oev',
ascending=False,
inplace=True)
short_portfolio.sort_values('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_pydatetime()))
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
}
elif strategy_class == 'ocs':
datetime_to = cu.convert_doubledate_2datetime(date_to)
time_held = (datetime_to.date() -
strategy_info_output['created_date'].date()).days
notes = ''
strategy_position = ts.get_net_position_4strategy_alias(
alias=kwargs['alias'], as_of_date=date_to, con=con)
if len(strategy_position.index) == 0:
tpnl.close_strategy(alias=kwargs['alias'],
close_date=date_to,
broker=broker,
con=con)
result_output = {
'success': True,
'time_held': time_held,
'dollar_noise': np.nan,
'notes': 'closed'
}
elif strategy_position['qty'].sum() != 0:
result_output = {
'success': True,
'time_held': time_held,
'dollar_noise': np.nan,
'notes': 'check position'
}
else:
strategy_position['cont_indx'] = [
cmi.get_contract_specs(x)['cont_indx']
for x in strategy_position['ticker']
]
strategy_position.sort_values('cont_indx',
ascending=True,
inplace=True)
ocs_output = ocs.generate_overnight_spreads_sheet_4date(
date_to=date_to)
overnight_calendars = ocs_output['overnight_calendars']
selection_indx = (overnight_calendars['ticker1'] == strategy_position['ticker'].iloc[0])&\
(overnight_calendars['ticker2'] == strategy_position['ticker'].iloc[1])
if sum(selection_indx) > 0:
dollar_noise = (overnight_calendars.loc[
selection_indx, 'dollarNoise100'].values[0]) * abs(
strategy_position['qty'].iloc[0])
else:
dollar_noise = np.nan
result_output = {
'success': True,
'time_held': time_held,
'dollar_noise': dollar_noise,
'notes': 'hold'
}
elif strategy_class == 'skpt':
long_ticker = strategy_position.loc[strategy_position['qty'] > 0,
'ticker'].iloc[0]
short_ticker = strategy_position.loc[strategy_position['qty'] < 0,
'ticker'].iloc[0]
long_data = gsp.get_stock_price_preloaded(ticker=long_ticker,
data_source='iex',
settle_date_to=date_to)
short_data = gsp.get_stock_price_preloaded(ticker=short_ticker,
data_source='iex',
settle_date_to=date_to)
merged_data = pd.merge(long_data[['close', 'settle_datetime']],
short_data[['close', 'settle_datetime']],
how='inner',
on='settle_datetime')
merged_data.set_index('settle_datetime', drop=True, inplace=True)
intaday_output_long = pweb.DataReader(long_ticker, 'iex-tops')
intaday_output_short = pweb.DataReader(short_ticker, 'iex-tops')
merged_data = merged_data.append(
pd.DataFrame(
{
'close_x': intaday_output_long.iloc[4].values[0],
'close_y': intaday_output_short.iloc[4].values[0]
},
index=[dt.datetime.now()]))
signal_output = spt.backtest(merged_data, 'close_x', 'close_y')
return {
'long_ticker': long_ticker,
'short_ticker': short_ticker,
'zScoreC': signal_output['data_frame']['zScore'].iloc[-1],
'zScore': signal_output['data_frame']['zScore'].iloc[-2]
}
else:
result_output = {'success': False}
if 'con' not in kwargs.keys():
con.close()
return result_output
def get_vcs_pairs_4date_legacy(**kwargs):
settle_date = kwargs['settle_date']
settle_datetime = cu.convert_doubledate_2datetime(settle_date)
con = msu.get_my_sql_connection(**kwargs)
liquid_options_frame = cl.generate_liquid_options_list_dataframe(settle_date=settle_date,con=con)
contract_specs_output = [cmi.get_contract_specs(x) for x in liquid_options_frame['ticker']]
liquid_options_frame['ticker_head'] = [x['ticker_head'] for x in contract_specs_output]
liquid_options_frame['ticker_month'] = [x['ticker_month_num'] for x in contract_specs_output]
liquid_options_frame['ticker_class'] = [x['ticker_class'] for x in contract_specs_output]
liquid_options_frame['cal_dte'] = [(x-settle_datetime.date()).days for x in liquid_options_frame['expiration_date']]
liquid_options_frame = liquid_options_frame[((liquid_options_frame['ticker_head'] == 'LN')&(liquid_options_frame['cal_dte'] <= 360))|
((liquid_options_frame['ticker_head']=='LC')&(liquid_options_frame['cal_dte']<=360)&
(liquid_options_frame['ticker_month']%2==0))|
((liquid_options_frame['ticker_head']=='LC')&(liquid_options_frame['cal_dte']<=40)&
(liquid_options_frame['ticker_month']%2==1))|
((liquid_options_frame['ticker_head']=='ES')&(liquid_options_frame['cal_dte']<=270))|
((liquid_options_frame['ticker_class']=='FX')&(liquid_options_frame['cal_dte']<=270)&
(liquid_options_frame['ticker_month']%3==0))|
((liquid_options_frame['ticker_class']=='FX')&(liquid_options_frame['cal_dte']<=70)&
(liquid_options_frame['ticker_month']%3!=0))|
((liquid_options_frame['ticker_head']=='GC')&(liquid_options_frame['cal_dte']<=360)&
(liquid_options_frame['ticker_month'].isin([6,12])))|
((liquid_options_frame['ticker_head']=='GC')&(liquid_options_frame['cal_dte']<=270)&
(liquid_options_frame['ticker_month'].isin([2,4,8,10])))|
((liquid_options_frame['ticker_head']=='GC')&(liquid_options_frame['cal_dte']<=70))|
((liquid_options_frame['ticker_head']=='SI')&(liquid_options_frame['cal_dte']<=360)&
(liquid_options_frame['ticker_month'].isin([7,12])))|
((liquid_options_frame['ticker_head']=='SI')&(liquid_options_frame['cal_dte']<=270)&
(liquid_options_frame['ticker_month'].isin([1,3,5,9])))|
((liquid_options_frame['ticker_head']=='SI')&(liquid_options_frame['cal_dte']<=70))|
((liquid_options_frame['ticker_class']=='Treasury')&(liquid_options_frame['cal_dte']<=180)&
(liquid_options_frame['ticker_month']%3==0))|
((liquid_options_frame['ticker_class']=='Treasury')&(liquid_options_frame['cal_dte']<=70)&
(liquid_options_frame['ticker_month']%3!=0))|
((liquid_options_frame['ticker_head']=='C')&(liquid_options_frame['cal_dte']<=540)&
(liquid_options_frame['ticker_month']==12))|
((liquid_options_frame['ticker_head']=='C')&(liquid_options_frame['cal_dte']<=360)&
(liquid_options_frame['ticker_month']==7))|
((liquid_options_frame['ticker_head']=='C')&(liquid_options_frame['cal_dte']<=270)&
(liquid_options_frame['ticker_month'].isin([3,5,9])))|
((liquid_options_frame['ticker_head']=='C')&(liquid_options_frame['cal_dte']<=40))|
((liquid_options_frame['ticker_head']=='S')&(liquid_options_frame['cal_dte']<=540)&
(liquid_options_frame['ticker_month']==11))|
((liquid_options_frame['ticker_head']=='S')&(liquid_options_frame['cal_dte']<=360)&
(liquid_options_frame['ticker_month']==7))|
((liquid_options_frame['ticker_head']=='S')&(liquid_options_frame['cal_dte']<=270)&
(liquid_options_frame['ticker_month'].isin([1,3,5,8,9])))|
((liquid_options_frame['ticker_head']=='S')&(liquid_options_frame['cal_dte']<=40))|
((liquid_options_frame['ticker_head']=='SM')&(liquid_options_frame['cal_dte']<=360)&
(liquid_options_frame['ticker_month']==12))|
((liquid_options_frame['ticker_head']=='SM')&(liquid_options_frame['cal_dte']<=270)&
(liquid_options_frame['ticker_month']==7))|
((liquid_options_frame['ticker_head']=='SM')&(liquid_options_frame['cal_dte']<=180)&
(liquid_options_frame['ticker_month'].isin([1,3,5,8,9,10])))|
((liquid_options_frame['ticker_head']=='SM')&(liquid_options_frame['cal_dte']<=40))|
((liquid_options_frame['ticker_head']=='BO')&(liquid_options_frame['cal_dte']<=360)&
(liquid_options_frame['ticker_month']==12))|
((liquid_options_frame['ticker_head']=='BO')&(liquid_options_frame['cal_dte']<=270)&
(liquid_options_frame['ticker_month']==7))|
((liquid_options_frame['ticker_head']=='BO')&(liquid_options_frame['cal_dte']<=180)&
(liquid_options_frame['ticker_month'].isin([1,3,5,8,9,10])))|
((liquid_options_frame['ticker_head']=='BO')&(liquid_options_frame['cal_dte']<=40))|
((liquid_options_frame['ticker_head']=='W')&(liquid_options_frame['cal_dte']<=360)&
(liquid_options_frame['ticker_month']==12))|
((liquid_options_frame['ticker_head']=='W')&(liquid_options_frame['cal_dte']<=270)&
(liquid_options_frame['ticker_month']==7))|
((liquid_options_frame['ticker_head']=='W')&(liquid_options_frame['cal_dte']<=180)&
(liquid_options_frame['ticker_month'].isin([3,5,9])))|
((liquid_options_frame['ticker_head']=='W')&(liquid_options_frame['cal_dte']<=40))|
((liquid_options_frame['ticker_head']=='CL')&(liquid_options_frame['cal_dte']<=720)&
(liquid_options_frame['ticker_month']==12))|
((liquid_options_frame['ticker_head']=='CL')&(liquid_options_frame['cal_dte']<=540)&
(liquid_options_frame['ticker_month']==6))|
((liquid_options_frame['ticker_head']=='CL')&(liquid_options_frame['cal_dte']<=180))|
((liquid_options_frame['ticker_head']=='NG')&(liquid_options_frame['cal_dte']<=360))]
liquid_options_frame.sort(['ticker_head','cal_dte'],ascending=[True,True],inplace=True)
liquid_options_frame['tr_dte'] = [exp.get_days2_expiration(date_to=settle_date,con=con,instrument='options',ticker=x)['tr_dte'] for x in liquid_options_frame['ticker']]
if 'con' not in kwargs.keys():
con.close()
option_frame = liquid_options_frame[liquid_options_frame['tr_dte'] >= 35]
option_frame.reset_index(drop=True,inplace=True)
unique_ticker_heads = option_frame['ticker_head'].unique()
tuples = []
for ticker_head_i in unique_ticker_heads:
ticker_head_data = option_frame[option_frame['ticker_head'] == ticker_head_i]
ticker_head_data.sort('cal_dte', ascending=True, inplace=True)
if len(ticker_head_data.index) >= 2:
for i in range(len(ticker_head_data.index)-1):
for j in range(i+1,len(ticker_head_data.index)):
tuples = tuples + [(ticker_head_data.index[i], ticker_head_data.index[j])]
return pd.DataFrame([(option_frame['ticker'][indx[0]],
option_frame['ticker'][indx[1]],
option_frame['ticker_head'][indx[0]],
option_frame['ticker_class'][indx[0]],
option_frame['tr_dte'][indx[0]],
option_frame['tr_dte'][indx[1]]) for indx in tuples],columns=['ticker1','ticker2','tickerHead','tickerClass','trDte1','trDte2'])
def get_vcs_pairs_4date_legacy(**kwargs):
settle_date = kwargs['settle_date']
settle_datetime = cu.convert_doubledate_2datetime(settle_date)
con = msu.get_my_sql_connection(**kwargs)
liquid_options_frame = cl.generate_liquid_options_list_dataframe(
settle_date=settle_date, con=con)
contract_specs_output = [
cmi.get_contract_specs(x) for x in liquid_options_frame['ticker']
]
liquid_options_frame['ticker_head'] = [
x['ticker_head'] for x in contract_specs_output
]
liquid_options_frame['ticker_month'] = [
x['ticker_month_num'] for x in contract_specs_output
]
liquid_options_frame['ticker_class'] = [
x['ticker_class'] for x in contract_specs_output
]
liquid_options_frame['cal_dte'] = [
(x - settle_datetime.date()).days
for x in liquid_options_frame['expiration_date']
]
liquid_options_frame = liquid_options_frame[
((liquid_options_frame['ticker_head'] == 'LN') &
(liquid_options_frame['cal_dte'] <= 360)) |
((liquid_options_frame['ticker_head'] == 'LC') &
(liquid_options_frame['cal_dte'] <= 360) &
(liquid_options_frame['ticker_month'] % 2 == 0)) |
((liquid_options_frame['ticker_head'] == 'LC') &
(liquid_options_frame['cal_dte'] <= 40) &
(liquid_options_frame['ticker_month'] % 2 == 1)) |
((liquid_options_frame['ticker_head'] == 'ES') &
(liquid_options_frame['cal_dte'] <= 270)) |
((liquid_options_frame['ticker_class'] == 'FX') &
(liquid_options_frame['cal_dte'] <= 270) &
(liquid_options_frame['ticker_month'] % 3 == 0)) |
((liquid_options_frame['ticker_class'] == 'FX') &
(liquid_options_frame['cal_dte'] <= 70) &
(liquid_options_frame['ticker_month'] % 3 != 0)) |
((liquid_options_frame['ticker_head'] == 'GC') &
(liquid_options_frame['cal_dte'] <= 360) &
(liquid_options_frame['ticker_month'].isin([6, 12]))) |
((liquid_options_frame['ticker_head'] == 'GC') &
(liquid_options_frame['cal_dte'] <= 270) &
(liquid_options_frame['ticker_month'].isin([2, 4, 8, 10]))) |
((liquid_options_frame['ticker_head'] == 'GC') &
(liquid_options_frame['cal_dte'] <= 70)) |
((liquid_options_frame['ticker_head'] == 'SI') &
(liquid_options_frame['cal_dte'] <= 360) &
(liquid_options_frame['ticker_month'].isin([7, 12]))) |
((liquid_options_frame['ticker_head'] == 'SI') &
(liquid_options_frame['cal_dte'] <= 270) &
(liquid_options_frame['ticker_month'].isin([1, 3, 5, 9]))) |
((liquid_options_frame['ticker_head'] == 'SI') &
(liquid_options_frame['cal_dte'] <= 70)) |
((liquid_options_frame['ticker_class'] == 'Treasury') &
(liquid_options_frame['cal_dte'] <= 180) &
(liquid_options_frame['ticker_month'] % 3 == 0)) |
((liquid_options_frame['ticker_class'] == 'Treasury') &
(liquid_options_frame['cal_dte'] <= 70) &
(liquid_options_frame['ticker_month'] % 3 != 0)) |
((liquid_options_frame['ticker_head'] == 'C') &
(liquid_options_frame['cal_dte'] <= 540) &
(liquid_options_frame['ticker_month'] == 12)) |
((liquid_options_frame['ticker_head'] == 'C') &
(liquid_options_frame['cal_dte'] <= 360) &
(liquid_options_frame['ticker_month'] == 7)) |
((liquid_options_frame['ticker_head'] == 'C') &
(liquid_options_frame['cal_dte'] <= 270) &
(liquid_options_frame['ticker_month'].isin([3, 5, 9]))) |
((liquid_options_frame['ticker_head'] == 'C') &
(liquid_options_frame['cal_dte'] <= 40)) |
((liquid_options_frame['ticker_head'] == 'S') &
(liquid_options_frame['cal_dte'] <= 540) &
(liquid_options_frame['ticker_month'] == 11)) |
((liquid_options_frame['ticker_head'] == 'S') &
(liquid_options_frame['cal_dte'] <= 360) &
(liquid_options_frame['ticker_month'] == 7)) |
((liquid_options_frame['ticker_head'] == 'S') &
(liquid_options_frame['cal_dte'] <= 270) &
(liquid_options_frame['ticker_month'].isin([1, 3, 5, 8, 9]))) |
((liquid_options_frame['ticker_head'] == 'S') &
(liquid_options_frame['cal_dte'] <= 40)) |
((liquid_options_frame['ticker_head'] == 'SM') &
(liquid_options_frame['cal_dte'] <= 360) &
(liquid_options_frame['ticker_month'] == 12)) |
((liquid_options_frame['ticker_head'] == 'SM') &
(liquid_options_frame['cal_dte'] <= 270) &
(liquid_options_frame['ticker_month'] == 7)) |
((liquid_options_frame['ticker_head'] == 'SM') &
(liquid_options_frame['cal_dte'] <= 180) &
(liquid_options_frame['ticker_month'].isin([1, 3, 5, 8, 9, 10]))) |
((liquid_options_frame['ticker_head'] == 'SM') &
(liquid_options_frame['cal_dte'] <= 40)) |
((liquid_options_frame['ticker_head'] == 'BO') &
(liquid_options_frame['cal_dte'] <= 360) &
(liquid_options_frame['ticker_month'] == 12)) |
((liquid_options_frame['ticker_head'] == 'BO') &
(liquid_options_frame['cal_dte'] <= 270) &
(liquid_options_frame['ticker_month'] == 7)) |
((liquid_options_frame['ticker_head'] == 'BO') &
(liquid_options_frame['cal_dte'] <= 180) &
(liquid_options_frame['ticker_month'].isin([1, 3, 5, 8, 9, 10]))) |
((liquid_options_frame['ticker_head'] == 'BO') &
(liquid_options_frame['cal_dte'] <= 40)) |
((liquid_options_frame['ticker_head'] == 'W') &
(liquid_options_frame['cal_dte'] <= 360) &
(liquid_options_frame['ticker_month'] == 12)) |
((liquid_options_frame['ticker_head'] == 'W') &
(liquid_options_frame['cal_dte'] <= 270) &
(liquid_options_frame['ticker_month'] == 7)) |
((liquid_options_frame['ticker_head'] == 'W') &
(liquid_options_frame['cal_dte'] <= 180) &
(liquid_options_frame['ticker_month'].isin([3, 5, 9]))) |
((liquid_options_frame['ticker_head'] == 'W') &
(liquid_options_frame['cal_dte'] <= 40)) |
((liquid_options_frame['ticker_head'] == 'CL') &
(liquid_options_frame['cal_dte'] <= 720) &
(liquid_options_frame['ticker_month'] == 12)) |
((liquid_options_frame['ticker_head'] == 'CL') &
(liquid_options_frame['cal_dte'] <= 540) &
(liquid_options_frame['ticker_month'] == 6)) |
((liquid_options_frame['ticker_head'] == 'CL') &
(liquid_options_frame['cal_dte'] <= 180)) |
((liquid_options_frame['ticker_head'] == 'NG') &
(liquid_options_frame['cal_dte'] <= 360))]
liquid_options_frame.sort(['ticker_head', 'cal_dte'],
ascending=[True, True],
inplace=True)
liquid_options_frame['tr_dte'] = [
exp.get_days2_expiration(date_to=settle_date,
con=con,
instrument='options',
ticker=x)['tr_dte']
for x in liquid_options_frame['ticker']
]
if 'con' not in kwargs.keys():
con.close()
option_frame = liquid_options_frame[liquid_options_frame['tr_dte'] >= 35]
option_frame.reset_index(drop=True, inplace=True)
unique_ticker_heads = option_frame['ticker_head'].unique()
tuples = []
for ticker_head_i in unique_ticker_heads:
ticker_head_data = option_frame[option_frame['ticker_head'] ==
ticker_head_i]
ticker_head_data.sort('cal_dte', ascending=True, inplace=True)
if len(ticker_head_data.index) >= 2:
for i in range(len(ticker_head_data.index) - 1):
for j in range(i + 1, len(ticker_head_data.index)):
tuples = tuples + [
(ticker_head_data.index[i], ticker_head_data.index[j])
]
return pd.DataFrame(
[(option_frame['ticker'][indx[0]], option_frame['ticker'][indx[1]],
option_frame['ticker_head'][indx[0]],
option_frame['ticker_class'][indx[0]],
option_frame['tr_dte'][indx[0]], option_frame['tr_dte'][indx[1]])
for indx in tuples],
columns=[
'ticker1', 'ticker2', 'tickerHead', 'tickerClass', 'trDte1',
'trDte2'
])
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_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 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
