def get_ocs_position(**kwargs):
net_position = ts.get_net_position_4strategy_alias(**kwargs)
empty_position_q = False
correct_position_q = False
scale = 0
if len(net_position.index) == 0:
empty_position_q = True
return {
'empty_position_q': empty_position_q,
'correct_position_q': correct_position_q,
'scale': scale,
'sorted_position': net_position
}
net_position['cont_indx'] = [
cmi.get_contract_specs(x)['cont_indx'] for x in net_position['ticker']
]
net_position.sort_values('cont_indx', ascending=True, inplace=True)
if (len(net_position.index) == 2) & (net_position['qty'].sum() == 0):
correct_position_q = True
scale = net_position['qty'].iloc[0]
return {
'empty_position_q': empty_position_q,
'correct_position_q': correct_position_q,
'scale': scale,
'sorted_position': net_position
}
def close_strategy(**kwargs):
alias = kwargs['alias']
if 'close_date' in kwargs.keys():
close_date = kwargs['close_date']
else:
close_date = exp.doubledate_shift_bus_days()
now_time = dt.datetime.now()
now_date = now_time.date()
con = msu.get_my_sql_connection(**kwargs)
net_position = ts.get_net_position_4strategy_alias(alias=alias, con=con, as_of_date=close_date)
if net_position.empty:
pnl_output = get_strategy_pnl(alias=alias, con=con, as_of_date=close_date)
total_pnl = pnl_output['total_pnl']
cur = con.cursor()
query_str = 'UPDATE strategy SET pnl=' + str(total_pnl) + \
', close_date=' + str(close_date) + \
', last_updated_date=' + now_date.strftime('%Y%m%d') + \
' WHERE alias=\'' + alias + '\''
cur.execute(query_str)
con.commit()
else:
print(alias + ' is not empty ! ')
return
if 'con' not in kwargs.keys():
con.close()
def get_greeks_4strategy_4date(**kwargs):
con = msu.get_my_sql_connection(**kwargs)
alias = kwargs['alias']
if 'as_of_date' in kwargs.keys():
as_of_date = kwargs['as_of_date']
else:
as_of_date = exp.doubledate_shift_bus_days()
position_frame = tas.get_net_position_4strategy_alias(alias=alias,as_of_date=as_of_date,con=con)
options_frame = position_frame[position_frame['instrument'] == 'O']
if options_frame.empty:
if 'con' not in kwargs.keys():
con.close()
return {'ticker_portfolio': pd.DataFrame(columns=['total_oev', 'theta','dollar_vega','ticker']), 'strike_portfolio': pd.DataFrame()}
unique_ticker_list = options_frame['ticker'].unique()
result_list = []
contract_specs_output_list = [cmi.get_contract_specs(x) for x in unique_ticker_list]
contract_multiplier_list = [cmi.contract_multiplier[x['ticker_head']] for x in contract_specs_output_list]
for i in range(len(unique_ticker_list)):
skew_output = gop.get_options_price_from_db(ticker=unique_ticker_list[i],
settle_date=as_of_date,
column_names=['option_type', 'strike', 'theta', 'vega', 'delta'])
skew_output.reset_index(drop=True,inplace=True)
skew_output['delta_diff'] = abs(skew_output['delta']-0.5)
atm_point = skew_output.loc[skew_output['delta_diff'].idxmin()]
skew_output.rename(columns={'strike': 'strike_price'}, inplace=True)
merged_data = pd.merge(options_frame[options_frame['ticker'] == unique_ticker_list[i]], skew_output, how='left', on=['option_type','strike_price'])
merged_data['oev'] = merged_data['vega']/atm_point['vega']
merged_data['total_oev'] = merged_data['oev']*merged_data['qty']
merged_data['dollar_theta'] = merged_data['theta']*merged_data['qty']*contract_multiplier_list[i]
merged_data['dollar_vega'] = merged_data['vega']*merged_data['qty']*contract_multiplier_list[i]/100
result_list.append(merged_data)
strike_portfolio = pd.concat(result_list)
grouped = strike_portfolio.groupby('ticker')
ticker_portfolio = pd.DataFrame()
ticker_portfolio['ticker'] = (grouped['ticker'].first()).values
ticker_portfolio['total_oev'] = (grouped['total_oev'].sum()).values
ticker_portfolio['theta'] = (grouped['dollar_theta'].sum()).values
ticker_portfolio['dollar_vega'] = (grouped['dollar_vega'].sum()).values
if 'con' not in kwargs.keys():
con.close()
return {'ticker_portfolio': ticker_portfolio, 'strike_portfolio': strike_portfolio }
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 close_strategy(**kwargs):
alias = kwargs['alias']
broker = kwargs['broker']
if 'close_date' in kwargs.keys():
close_date = kwargs['close_date']
else:
close_date = exp.doubledate_shift_bus_days()
now_time = dt.datetime.now()
now_date = now_time.date()
con = msu.get_my_sql_connection(**kwargs)
net_position = ts.get_net_position_4strategy_alias(alias=alias,
con=con,
as_of_date=close_date)
if net_position.empty:
pnl_output = get_strategy_pnl(alias=alias,
broker=broker,
con=con,
as_of_date=close_date)
total_pnl = pnl_output['total_pnl']
cur = con.cursor()
query_str = 'UPDATE strategy SET pnl=' + str(total_pnl) + \
', close_date=' + str(close_date) + \
', last_updated_date=' + now_date.strftime('%Y%m%d') + \
' WHERE alias=\'' + alias + '\''
cur.execute(query_str)
con.commit()
else:
print(alias + ' is not empty ! ')
return
if 'con' not in kwargs.keys():
con.close()
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_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_days_2roll'] = position_frame.apply(
lambda x: exp.get_days2_roll(ticker=x['ticker'],
instrument=x['instrument'],
date_to=kwargs['as_of_date'],
con=con)['tr_days_2roll'],
axis=1)
position_frame['alias'] = kwargs['alias']
if 'con' not in kwargs.keys():
con.close()
return position_frame
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 tickPrice(self, reqId: TickerId, tickType: TickType, price: float,
attrib: TickAttrib):
super().tickPrice(reqId, tickType, price, attrib)
ticker_str = self.market_data_ReqId_dictionary[reqId]
if tickType == 1:
self.bid_price_dictionary[ticker_str] = price
if ticker_str in self.nonfinished_bid_price_list:
self.nonfinished_bid_price_list.remove(ticker_str)
elif tickType == 2:
self.ask_price_dictionary[ticker_str] = price
if ticker_str in self.nonfinished_ask_price_list:
self.nonfinished_ask_price_list.remove(ticker_str)
if (tickType == 1) or (tickType == 2):
self.fair_price_dictionary[ticker_str] = self.calculate_mid_price(
ticker_str)
if (len(self.nonfinished_bid_price_list)==0)&(len(self.nonfinished_ask_price_list)==0)&\
(len(self.nonfinished_bid_quantity_list)==0)&(len(self.nonfinished_ask_quantity_list)==0)&(~self.option_model_call_initiated_q):
fair_price_dictionary = self.fair_price_dictionary
print(self.bid_price_dictionary)
underlying_ticker_list = []
mid_price_list = []
for key in fair_price_dictionary:
selection_indx = self.contract_frame['ticker'] == key
self.contract_frame['mid_price'].loc[
selection_indx] = fair_price_dictionary[key]
self.contract_frame['bid_p'].loc[
selection_indx] = self.bid_price_dictionary[key]
self.contract_frame['ask_p'].loc[
selection_indx] = self.ask_price_dictionary[key]
self.contract_frame['bid_q'].loc[
selection_indx] = self.bid_quantity_dictionary[key]
self.contract_frame['ask_q'].loc[
selection_indx] = self.ask_quantity_dictionary[key]
#self.contract_frame['underlying_ticker'] = self.contract_frame['ticker']
self.contract_frame['spread_cost'] = self.contract_frame[
'contract_multiplier'] * (self.contract_frame['ask_p'] -
self.contract_frame['bid_p'])
self.contract_frame['urgency_aux'] = self.contract_frame[
'risk'] / self.contract_frame['spread_cost']
self.contract_frame['urgency'] = 0
self.contract_frame['urgency'].loc[
self.contract_frame['urgency_aux'] > 5] = 100
self.contract_frame.rename(columns={'ticker': 'underlying_ticker'},
inplace=True)
self.option_model_call_initiated_q = True
#print(self.contract_frame)
tsh.strategy_hedge_report(intraday_price_frame=self.contract_frame,
delta_alias=self.delta_alias,
con=self.con)
position_frame = tas.get_net_position_4strategy_alias(
alias=self.delta_alias,
as_of_date=self.current_date,
con=self.con)
print(position_frame)
hedge_frame = tsh.get_hedge_frame(con=self.con)
hedge_aux = self.contract_frame
hedge_aux.rename(columns={'underlying_ticker': 'ticker'},
inplace=True)
hedge_aux = hedge_aux[['ticker', 'urgency']]
hedge_frame = pd.merge(hedge_frame,
hedge_aux,
how='inner',
on='ticker')
unique_ticker_head_list = hedge_frame['ticker_head'].unique()
for i in range(len(unique_ticker_head_list)):
hedge_frame_ticker_head = hedge_frame[
hedge_frame['ticker_head'] == unique_ticker_head_list[i]]
for j in range(len(hedge_frame_ticker_head.index)):
self.log.info(
str(hedge_frame_ticker_head['hedge'].iloc[j]) + ' ' +
hedge_frame_ticker_head['ticker'].iloc[j] +
' with urgency ' +
'% 4.1f' % hedge_frame_ticker_head['urgency'].iloc[j])
continue_q = 'n'
if len(hedge_frame.index) == 0:
self.log.info('No hedging needed today')
else:
continue_q = input('Do you agree? (y/n): ')
if continue_q == 'y':
self.log.info('Hedging now')
for i in range(len(hedge_frame.index)):
ticker_i = hedge_frame['ticker'].iloc[i]
split_output = ticker_i.split('-')
contract_specs_output = cmi.get_contract_specs(
split_output[0])
tick_size = cmi.tick_size[
contract_specs_output['ticker_head']]
action_str = ''
trade_quantity = abs(hedge_frame['hedge'].iloc[i])
if hedge_frame['hedge'].iloc[i] > 0:
if hedge_frame['urgency'].iloc[i] == 100:
limit_price = self.ask_price_dictionary[ticker_i]
else:
limit_price = m.ceil(
self.fair_price_dictionary[ticker_i] /
tick_size) * tick_size
action_str = 'BUY'
else:
if hedge_frame['urgency'].iloc[i] == 100:
limit_price = self.bid_price_dictionary[ticker_i]
else:
limit_price = m.floor(
self.fair_price_dictionary[ticker_i] /
tick_size) * tick_size
action_str = 'SELL'
if hedge_frame['is_spread_q'].iloc[i]:
contract_i = self.spread_contract_dictionary[ticker_i]
order = ib_api_trade.ComboLimitOrder(
action_str, trade_quantity, limit_price, False)
else:
contract_i = self.outright_contract_dictionary[
ticker_i]
order = ib_api_trade.LimitOrder(
action_str, trade_quantity, limit_price)
self.order_ticker_dictionary[self.next_val_id] = ticker_i
self.order_urgency_dictionary[
self.next_val_id] = hedge_frame['urgency'].iloc[i]
self.placeOrder(self.next_valid_id(), contract_i, order)
def get_intraday_data_contract_frame(**kwargs):
current_date = cu.get_doubledate()
con = msu.get_my_sql_connection(**kwargs)
strategy_frame = tas.get_open_strategies(as_of_date=current_date, con=con)
strategy_class_list = [
sc.convert_from_string_to_dictionary(
string_input=strategy_frame['description_string'][x])
['strategy_class'] for x in range(len(strategy_frame.index))
]
hedge_indx = [
x in ['vcs', 'scv', 'optionInventory'] for x in strategy_class_list
]
hedge_frame = strategy_frame[hedge_indx]
options_frame_list = []
for i in range(len(hedge_frame.index)):
position_frame = tas.get_net_position_4strategy_alias(
alias=hedge_frame['alias'].iloc[i],
as_of_date=current_date,
con=con)
options_frame = position_frame[position_frame['instrument'] == 'O']
options_frame['underlying_ticker'] = [
omu.get_option_underlying(ticker=x)
for x in options_frame['ticker']
]
options_frame_list.append(options_frame)
merged_frame = pd.concat(options_frame_list)
underlying_ticker_list = list(merged_frame['underlying_ticker'].unique())
delta_alias = get_delta_strategy_alias(con=con)
delta_position_frame = tas.get_net_position_4strategy_alias(
alias=delta_alias, as_of_date=current_date, con=con)
contract_frame = pd.DataFrame()
contract_frame['ticker'] = list(
set(delta_position_frame['ticker'].unique())
| set(underlying_ticker_list))
contract_specs_output_list = [
cmi.get_contract_specs(x) for x in contract_frame['ticker']
]
contract_frame['ticker_head'] = [
x['ticker_head'] for x in contract_specs_output_list
]
contract_frame['ticker_class'] = [
x['ticker_class'] for x in contract_specs_output_list
]
contract_frame['cont_indx'] = [
x['cont_indx'] for x in contract_specs_output_list
]
contract_frame['is_spread_q'] = False
contract_frame.sort_values(['ticker_head', 'cont_indx'],
ascending=[True, True],
inplace=True)
contract_frame.reset_index(drop=True, inplace=True)
non_flat_frame = contract_frame[~contract_frame['ticker_class'].
isin(flat_curve_ticker_class_list)]
unique_ticker_head_list = non_flat_frame['ticker_head'].unique()
for i in range(len(unique_ticker_head_list)):
ticker_head_frame = non_flat_frame[non_flat_frame['ticker_head'] ==
unique_ticker_head_list[i]]
if len(ticker_head_frame.index) > 1:
for j in range(len(ticker_head_frame.index) - 1):
for k in range(j + 1, len(ticker_head_frame.index)):
spread_ticker = ticker_head_frame['ticker'].iloc[
j] + '-' + ticker_head_frame['ticker'].iloc[k]
contract_frame.loc[len(contract_frame.index)] = [
spread_ticker,
ticker_head_frame['ticker_head'].iloc[j],
ticker_head_frame['ticker_class'].iloc[j],
ticker_head_frame['cont_indx'].iloc[j], True
]
if 'con' not in kwargs.keys():
con.close()
return contract_frame
def get_historical_risk_4strategy(**kwargs):
con = msu.get_my_sql_connection(**kwargs)
alias = kwargs['alias']
#print(alias)
if 'as_of_date' in kwargs.keys():
as_of_date = kwargs['as_of_date']
else:
as_of_date = exp.doubledate_shift_bus_days()
if 'datetime5_years_ago' in kwargs.keys():
datetime5_years_ago = kwargs['datetime5_years_ago']
else:
date5_years_ago = cu.doubledate_shift(as_of_date,5*365)
datetime5_years_ago = cu.convert_doubledate_2datetime(date5_years_ago)
net_position = ts.get_net_position_4strategy_alias(alias=alias,con=con)
net_position = net_position[net_position['instrument'] != 'O']
if 'con' not in kwargs.keys():
con.close()
if net_position.empty:
return {'downside': 0, 'pnl_5_change': []}
amcb_output = [opUtil.get_aggregation_method_contracts_back(cmi.get_contract_specs(x)) for x in net_position['ticker']]
aggregation_method = pd.DataFrame(amcb_output)['aggregation_method'].max()
if aggregation_method == 12:
contracts_back = const.annualContractsBack
elif aggregation_method == 3:
contracts_back = const.quarterlyContractsBack
elif aggregation_method == 1:
contracts_back = const.monthlyContractsBack
aligned_output = opUtil.get_aligned_futures_data(contract_list=net_position['ticker'].values,
aggregation_method=aggregation_method,
contracts_back=contracts_back,date_to=as_of_date,**kwargs)
aligned_data = aligned_output['aligned_data']
last5_years_indx = aligned_data['settle_date'] >= datetime5_years_ago
data_last5_years = aligned_data[last5_years_indx]
ticker_head_list = [cmi.get_contract_specs(x)['ticker_head'] for x in net_position['ticker']]
contract_multiplier_list = [cmi.contract_multiplier[x] for x in ticker_head_list]
pnl_5_change_list = [contract_multiplier_list[x]*
net_position['qty'].iloc[x]*
data_last5_years['c' + str(x+1)]['change_5'] for x in range(len(net_position.index))]
pnl_5_change = sum(pnl_5_change_list)
percentile_vector = stats.get_number_from_quantile(y=pnl_5_change.values,
quantile_list=[1, 15],
clean_num_obs=max(100, round(3*len(pnl_5_change.values)/4)))
downside = (percentile_vector[0]+percentile_vector[1])/2
unique_ticker_head_list = list(set(ticker_head_list))
ticker_head_based_pnl_5_change = {x: sum([pnl_5_change_list[y] for y in range(len(ticker_head_list)) if ticker_head_list[y] == x])
for x in unique_ticker_head_list}
return {'downside': downside, 'pnl_5_change': pnl_5_change,'ticker_head_based_pnl_5_change':ticker_head_based_pnl_5_change}
def get_historical_risk_4strategy(**kwargs):
con = msu.get_my_sql_connection(**kwargs)
alias = kwargs['alias']
#print(alias)
if 'as_of_date' in kwargs.keys():
as_of_date = kwargs['as_of_date']
else:
as_of_date = exp.doubledate_shift_bus_days()
if 'datetime5_years_ago' in kwargs.keys():
datetime5_years_ago = kwargs['datetime5_years_ago']
else:
date5_years_ago = cu.doubledate_shift(as_of_date,5*365)
datetime5_years_ago = cu.convert_doubledate_2datetime(date5_years_ago)
net_position = ts.get_net_position_4strategy_alias(alias=alias,con=con)
net_position = net_position[net_position['instrument'] != 'O']
if 'con' not in kwargs.keys():
con.close()
if net_position.empty:
return {'downside': 0, 'pnl_5_change': []}
amcb_output = [opUtil.get_aggregation_method_contracts_back(cmi.get_contract_specs(x)) for x in net_position['ticker']]
aggregation_method = pd.DataFrame(amcb_output)['aggregation_method'].max()
if aggregation_method == 12:
contracts_back = const.annualContractsBack
elif aggregation_method == 3:
contracts_back = const.quarterlyContractsBack
elif aggregation_method == 1:
contracts_back = const.monthlyContractsBack
aligned_output = opUtil.get_aligned_futures_data(contract_list=net_position['ticker'].values,
aggregation_method=aggregation_method,
contracts_back=contracts_back,date_to=as_of_date,**kwargs)
aligned_data = aligned_output['aligned_data']
last5_years_indx = aligned_data['settle_date'] >= datetime5_years_ago
data_last5_years = aligned_data[last5_years_indx]
ticker_head_list = [cmi.get_contract_specs(x)['ticker_head'] for x in net_position['ticker']]
contract_multiplier_list = [cmi.contract_multiplier[x] for x in ticker_head_list]
pnl_5_change_list = [contract_multiplier_list[x]*
net_position['qty'].iloc[x]*
data_last5_years['c' + str(x+1)]['change_5'] for x in range(len(net_position.index))]
pnl_5_change = sum(pnl_5_change_list)
percentile_vector = stats.get_number_from_quantile(y=pnl_5_change.values,
quantile_list=[1, 15],
clean_num_obs=max(100, round(3*len(pnl_5_change.values)/4)))
downside = (percentile_vector[0]+percentile_vector[1])/2
unique_ticker_head_list = list(set(ticker_head_list))
ticker_head_based_pnl_5_change = {x: sum([pnl_5_change_list[y] for y in range(len(ticker_head_list)) if ticker_head_list[y] == x])
for x in unique_ticker_head_list}
return {'downside': downside, 'pnl_5_change': pnl_5_change,'ticker_head_based_pnl_5_change':ticker_head_based_pnl_5_change}
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
#return option_frame
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 get_hedge_frame(**kwargs):
con = msu.get_my_sql_connection(**kwargs)
delta_alias = get_delta_strategy_alias(con=con)
current_date = cu.get_doubledate()
delta_position_frame = tas.get_net_position_4strategy_alias(
alias=delta_alias, as_of_date=current_date, con=con)
contract_specs_output_list = [
cmi.get_contract_specs(x) for x in delta_position_frame['ticker']
]
delta_position_frame['ticker_head'] = [
x['ticker_head'] for x in contract_specs_output_list
]
delta_position_frame['ticker_class'] = [
x['ticker_class'] for x in contract_specs_output_list
]
delta_position_frame['cont_indx'] = [
x['cont_indx'] for x in contract_specs_output_list
]
#delta_position_frame['qty'].iloc[0] = 2
#delta_position_frame['qty'].iloc[1] = -1
#delta_position_frame['qty'].iloc[2] = 1
non_flat_frame = delta_position_frame[~delta_position_frame['ticker_class']
.isin(flat_curve_ticker_class_list)]
unique_ticker_head_list = non_flat_frame['ticker_head'].unique()
non_flat_curve_hedge_frame = pd.DataFrame(columns=[
'ticker', 'ticker_head', 'is_spread_q', 'is_expiration_roll_q',
'tr_days_2_roll', 'hedge'
])
for i in range(len(unique_ticker_head_list)):
ticker_head_frame = non_flat_frame[non_flat_frame['ticker_head'] ==
unique_ticker_head_list[i]]
ticker_head_frame.reset_index(drop=True, inplace=True)
if len(ticker_head_frame.index) == 1:
non_flat_curve_hedge_frame.loc[len(non_flat_curve_hedge_frame.index)] = \
[ticker_head_frame['ticker'].iloc[0], ticker_head_frame['ticker_head'].iloc[0],
False, False, 100, calc_hedge_quantity(qty=ticker_head_frame['qty'].iloc[0])]
continue
raw_sum = ticker_head_frame['qty'].sum()
outright_hedge = calc_hedge_quantity(qty=raw_sum)
max_indx = ticker_head_frame['qty'].idxmax()
min_indx = ticker_head_frame['qty'].idxmin()
if (outright_hedge > 0):
non_flat_curve_hedge_frame.loc[len(non_flat_curve_hedge_frame.index)] = \
[ticker_head_frame['ticker'].loc[min_indx], ticker_head_frame['ticker_head'].loc[min_indx],
False, False, 100, outright_hedge]
ticker_head_frame['qty'].loc[min_indx] = ticker_head_frame[
'qty'].loc[min_indx] + outright_hedge
if (outright_hedge < 0):
non_flat_curve_hedge_frame.loc[len(non_flat_curve_hedge_frame.index)] = \
[ticker_head_frame['ticker'].loc[max_indx], ticker_head_frame['ticker_head'].loc[max_indx],
False, False, 100, outright_hedge]
ticker_head_frame['qty'].loc[max_indx] = ticker_head_frame[
'qty'].loc[max_indx] + outright_hedge
position_cleaned_q = False
while (not position_cleaned_q):
max_indx2 = ticker_head_frame['qty'].idxmax()
min_indx2 = ticker_head_frame['qty'].idxmin()
position_cleaned_q = not (
(ticker_head_frame['qty'].loc[max_indx2] >= 1) and
(ticker_head_frame['qty'].loc[min_indx2] <= -1))
if position_cleaned_q:
break
spread_hedge = calc_hedge_quantity(
qty=min(ticker_head_frame['qty'].loc[max_indx2],
-ticker_head_frame['qty'].loc[min_indx2]))
if ticker_head_frame['cont_indx'].loc[
max_indx2] < ticker_head_frame['cont_indx'].loc[min_indx2]:
spread_ticker = ticker_head_frame['ticker'].loc[
max_indx2] + '-' + ticker_head_frame['ticker'].loc[
min_indx2]
hedge_qty = spread_hedge
else:
spread_ticker = ticker_head_frame['ticker'].loc[
min_indx2] + '-' + ticker_head_frame['ticker'].loc[
max_indx2]
hedge_qty = -spread_hedge
non_flat_curve_hedge_frame.loc[len(non_flat_curve_hedge_frame.index)] = \
[spread_ticker, unique_ticker_head_list[i], True, False, 100, hedge_qty]
ticker_head_frame['qty'].loc[max_indx2] = ticker_head_frame[
'qty'].loc[max_indx2] + spread_hedge
ticker_head_frame['qty'].loc[min_indx2] = ticker_head_frame[
'qty'].loc[min_indx2] - spread_hedge
if 'con' not in kwargs.keys():
con.close()
return non_flat_curve_hedge_frame
def get_hedge_4strategy(**kwargs):
con = msu.get_my_sql_connection(**kwargs)
current_date = cu.get_doubledate()
settle_price_date = exp.doubledate_shift_bus_days(double_date=current_date, shift_in_days=1)
position_frame = tas.get_net_position_4strategy_alias(alias=kwargs['alias'],as_of_date=current_date,con=con)
intraday_price_frame = gip.get_cme_direct_prices()
intraday_price_frame.rename(columns={'ticker': 'underlying_ticker'},inplace=True)
intraday_price_frame['ticker_head'] = [cmi.get_contract_specs(x)['ticker_head'] for x in intraday_price_frame['underlying_ticker']]
intraday_price_frame['mid_price'] = (intraday_price_frame['bid_price'] + intraday_price_frame['ask_price'])/2
intraday_price_frame['mid_price'] = [tfl.convert_trade_price_from_cme_direct(ticker_head=intraday_price_frame['ticker_head'].iloc[x],
price=intraday_price_frame['mid_price'].iloc[x]) for x in range(len(intraday_price_frame.index))]
options_frame = position_frame[position_frame['instrument'] == 'O']
futures_frame = position_frame[position_frame['instrument'] == 'F']
if options_frame.empty:
futures_frame.rename(columns={'ticker': 'underlying_ticker', 'qty': 'underlying_delta'},inplace=True)
futures_frame = futures_frame[['underlying_ticker', 'underlying_delta']]
net_position = pd.merge(futures_frame, intraday_price_frame, how='left', on='underlying_ticker')
net_position['hedge_price'] = net_position['mid_price']
net_position['hedge'] = -net_position['underlying_delta']
return net_position
imp_vol_list = [gop.get_options_price_from_db(ticker=options_frame['ticker'].iloc[x],
settle_date=settle_price_date,
strike=options_frame['strike_price'].iloc[x],
column_names=['imp_vol'],
con=con)['imp_vol'] for x in range(len(options_frame.index))]
options_frame['imp_vol'] = [imp_vol_list[x][1] if (np.isnan(imp_vol_list[x][0]) and len(imp_vol_list[x]) > 1) else imp_vol_list[x][0]
for x in range(len(options_frame.index))]
options_frame['underlying_ticker'] = [omu.get_option_underlying(ticker=x) for x in options_frame['ticker']]
options_frame = pd.merge(options_frame, intraday_price_frame, how='left', on='underlying_ticker')
options_frame['ticker_head'] = [cmi.get_contract_specs(x)['ticker_head'] for x in options_frame['ticker']]
options_frame['exercise_type'] = [cmi.get_option_exercise_type(ticker_head=x) for x in options_frame['ticker_head']]
options_frame['strike_price'] = options_frame['strike_price'].astype('float64')
options_frame['delta'] = [omu.option_model_wrapper(ticker=options_frame['ticker'].iloc[x],
calculation_date=current_date,
interest_rate_date=settle_price_date,
underlying=options_frame['mid_price'].iloc[x],
strike=options_frame['strike_price'].iloc[x],
implied_vol=options_frame['imp_vol'].iloc[x],
option_type=options_frame['option_type'].iloc[x],
exercise_type=options_frame['exercise_type'].iloc[x],
con=con)['delta'] for x in range(len(options_frame.index))]
options_frame['total_delta'] = options_frame['qty']*options_frame['delta']
grouped = options_frame.groupby('underlying_ticker')
net_position = pd.DataFrame()
net_position['underlying_ticker'] = (grouped['underlying_ticker'].first()).values
net_position['hedge_price'] = (grouped['mid_price'].first()).values
net_position['option_delta'] = (grouped['total_delta'].sum()).values
net_position['option_delta'] = net_position['option_delta'].round(2)
if futures_frame.empty:
net_position['total_delta'] = net_position['option_delta']
else:
futures_frame.rename(columns={'ticker': 'underlying_ticker', 'qty': 'underlying_delta'},inplace=True)
futures_frame = futures_frame[['underlying_ticker', 'underlying_delta']]
isinOptions = futures_frame['underlying_ticker'].isin(net_position['underlying_ticker'])
futures_frame_w_options = futures_frame[isinOptions]
futures_frame_wo_options = futures_frame[~isinOptions]
if futures_frame_w_options.empty:
net_position['underlying_delta'] = 0
net_position['total_delta'] = net_position['option_delta']
else:
net_position = pd.merge(net_position, futures_frame_w_options, how='outer', on='underlying_ticker')
net_position['total_delta'] = net_position['option_delta']+net_position['underlying_delta']
if not futures_frame_wo_options.empty:
net_position_futures = pd.merge(futures_frame_wo_options, intraday_price_frame, how='left', on='underlying_ticker')
net_position_futures['hedge_price'] = net_position_futures['mid_price']
net_position_futures['option_delta'] = 0
net_position_futures['total_delta'] = net_position_futures['underlying_delta']
net_position = pd.concat([net_position,net_position_futures[['underlying_ticker','hedge_price','option_delta','underlying_delta','total_delta']]])
net_position['hedge'] = -net_position['total_delta']
if 'con' not in kwargs.keys():
con.close()
return net_position
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_hedge_4strategy(**kwargs):
con = msu.get_my_sql_connection(**kwargs)
current_date = cu.get_doubledate()
settle_price_date = exp.doubledate_shift_bus_days(double_date=current_date,
shift_in_days=1)
position_frame = tas.get_net_position_4strategy_alias(
alias=kwargs['alias'], as_of_date=current_date, con=con)
if 'intraday_price_frame' in kwargs.keys():
intraday_price_frame = kwargs['intraday_price_frame']
else:
intraday_price_frame = gip.get_cme_direct_prices()
intraday_price_frame.rename(columns={'ticker': 'underlying_ticker'},
inplace=True)
intraday_price_frame['ticker_head'] = [
cmi.get_contract_specs(x)['ticker_head']
for x in intraday_price_frame['underlying_ticker']
]
intraday_price_frame['mid_price'] = (
intraday_price_frame['bid_price'] +
intraday_price_frame['ask_price']) / 2
intraday_price_frame['mid_price'] = [
tfl.convert_trade_price_from_cme_direct(
ticker_head=intraday_price_frame['ticker_head'].iloc[x],
price=intraday_price_frame['mid_price'].iloc[x])
for x in range(len(intraday_price_frame.index))
]
options_frame = position_frame[position_frame['instrument'] == 'O']
futures_frame = position_frame[position_frame['instrument'] == 'F']
if options_frame.empty:
futures_frame.rename(columns={
'ticker': 'underlying_ticker',
'qty': 'underlying_delta'
},
inplace=True)
futures_frame = futures_frame[[
'underlying_ticker', 'underlying_delta'
]]
net_position = pd.merge(futures_frame,
intraday_price_frame,
how='left',
on='underlying_ticker')
net_position['hedge_price'] = net_position['mid_price']
net_position['hedge'] = -net_position['underlying_delta']
return net_position
imp_vol_list = [
gop.get_options_price_from_db(
ticker=options_frame['ticker'].iloc[x],
settle_date=settle_price_date,
strike=options_frame['strike_price'].iloc[x],
column_names=['imp_vol'],
con=con)['imp_vol'] for x in range(len(options_frame.index))
]
options_frame['imp_vol'] = [
imp_vol_list[x][1] if
(np.isnan(imp_vol_list[x][0])
and len(imp_vol_list[x]) > 1) else imp_vol_list[x][0]
for x in range(len(options_frame.index))
]
options_frame['underlying_ticker'] = [
omu.get_option_underlying(ticker=x) for x in options_frame['ticker']
]
#print(intraday_price_frame)
options_frame = pd.merge(options_frame,
intraday_price_frame,
how='left',
on='underlying_ticker')
options_frame['ticker_head'] = [
cmi.get_contract_specs(x)['ticker_head']
for x in options_frame['ticker']
]
options_frame['exercise_type'] = [
cmi.get_option_exercise_type(ticker_head=x)
for x in options_frame['ticker_head']
]
options_frame['strike_price'] = options_frame['strike_price'].astype(
'float64')
options_frame['delta'] = [
omu.option_model_wrapper(
ticker=options_frame['ticker'].iloc[x],
calculation_date=current_date,
interest_rate_date=settle_price_date,
underlying=options_frame['mid_price'].iloc[x],
strike=options_frame['strike_price'].iloc[x],
implied_vol=options_frame['imp_vol'].iloc[x],
option_type=options_frame['option_type'].iloc[x],
exercise_type=options_frame['exercise_type'].iloc[x],
con=con)['delta'] for x in range(len(options_frame.index))
]
options_frame[
'total_delta'] = options_frame['qty'] * options_frame['delta']
grouped = options_frame.groupby('underlying_ticker')
net_position = pd.DataFrame()
net_position['underlying_ticker'] = (
grouped['underlying_ticker'].first()).values
net_position['hedge_price'] = (grouped['mid_price'].first()).values
net_position['option_delta'] = (grouped['total_delta'].sum()).values
net_position['option_delta'] = net_position['option_delta'].round(2)
if futures_frame.empty:
net_position['total_delta'] = net_position['option_delta']
else:
futures_frame.rename(columns={
'ticker': 'underlying_ticker',
'qty': 'underlying_delta'
},
inplace=True)
futures_frame = futures_frame[[
'underlying_ticker', 'underlying_delta'
]]
isinOptions = futures_frame['underlying_ticker'].isin(
net_position['underlying_ticker'])
futures_frame_w_options = futures_frame[isinOptions]
futures_frame_wo_options = futures_frame[~isinOptions]
if futures_frame_w_options.empty:
net_position['underlying_delta'] = 0
net_position['total_delta'] = net_position['option_delta']
else:
net_position = pd.merge(net_position,
futures_frame_w_options,
how='outer',
on='underlying_ticker')
net_position[['underlying_delta'
]] = net_position[['underlying_delta'
]].fillna(value=0, inplace=False)
net_position['total_delta'] = net_position[
'option_delta'] + net_position['underlying_delta']
if not futures_frame_wo_options.empty:
net_position_futures = pd.merge(futures_frame_wo_options,
intraday_price_frame,
how='left',
on='underlying_ticker')
net_position_futures['hedge_price'] = net_position_futures[
'mid_price']
net_position_futures['option_delta'] = 0
net_position_futures['total_delta'] = net_position_futures[
'underlying_delta']
net_position = pd.concat([
net_position, net_position_futures[[
'underlying_ticker', 'hedge_price', 'option_delta',
'underlying_delta', 'total_delta'
]]
])
net_position['hedge'] = -net_position['total_delta']
if 'con' not in kwargs.keys():
con.close()
return net_position
