def get_signals_4date(**kwargs):
report_date = kwargs['report_date']
date_from = cu.doubledate_shift(report_date, 365)
report_datetime = cu.convert_doubledate_2datetime(report_date)
fund_price_dictionary = {
x: gsp.get_stock_price_preloaded(ticker=x,
settle_date_from=date_from,
settle_date_to=report_date)
for x in symbol_list
}
data_current_dictionary = {
x:
fund_price_dictionary[x]['settle_datetime'].iloc[-1] == report_datetime
for x in symbol_list
}
symbols2update = []
for key, value in data_current_dictionary.items():
if not value:
symbols2update.append(key)
if symbols2update:
ssd.save_stock_data(symbol_list=symbols2update)
fund_price_dictionary = {
x: gsp.get_stock_price_preloaded(ticker=x,
settle_date_from=date_from,
settle_date_to=report_date)
for x in symbol_list
}
performance_dictionary = {}
for j in range((len(symbol_list))):
price_data = fund_price_dictionary[symbol_list[j]]
if price_data['settle_datetime'].iloc[-1] != report_datetime:
return {'success': False, 'performance_dictionary': {}}
price_data.reset_index(drop=True, inplace=True)
#split_envents = price_data[price_data['split_coefficient'] != 1]
#split_index_list = split_envents.index
#for i in range(len(split_index_list)):
# price_data['close'].iloc[:split_index_list[i]] = \
# price_data['close'].iloc[:split_index_list[i]] / price_data['split_coefficient'].iloc[split_index_list[i]]
# price_data['dividend_amount'].iloc[:split_index_list[i]] = \
# price_data['dividend_amount'].iloc[:split_index_list[i]] / price_data['split_coefficient'].iloc[split_index_list[i]]
performance_dictionary[symbol_list[j]] = 100 * (
price_data['close'].iloc[-1] -
price_data['close'].iloc[0]) / price_data['close'].iloc[0]
return {'success': True, 'performance_dictionary': performance_dictionary}
def get_summary(**kwargs):
symbol1 = kwargs['symbol1']
symbol2 = kwargs['symbol2']
report_date = kwargs['report_date']
if 'get_diagnosticQ' in kwargs.keys():
get_diagnosticQ = kwargs['get_diagnosticQ']
else:
get_diagnosticQ = False
report_datetime = cu.convert_doubledate_2datetime(report_date)
data1 = gsp.get_stock_price_preloaded(ticker=symbol1, data_source='iex', settle_date_to = report_date)
data2 = gsp.get_stock_price_preloaded(ticker=symbol2, data_source='iex', settle_date_to = report_date)
merged_data = pd.merge(data1[['close','settle_datetime']], data2[['close','settle_datetime']], how='inner', on='settle_datetime')
split = int(len(merged_data) * .4)
if split<200 or report_datetime!=merged_data['settle_datetime'].iloc[-1]:
return {'price1': np.nan,'price2': np.nan, 'p_value_2': np.nan,'p_value_1': np.nan,
'beta_1': np.nan, 'beta_2': np.nan,
'corr': np.nan,
'cagr1': np.nan, 'cagr2': np.nan,
'kalpha': np.nan, 'kbeta': np.nan,
'meanSpread': np.nan, 'stdSpread': np.nan,
'zScore': np.nan}
training_data = merged_data[:split]
test_data = merged_data[split:]
cointegration_output_2 = sm.tsa.stattools.coint(training_data['close_x'], training_data['close_y'])
cointegration_output_1 = sm.tsa.stattools.coint(test_data['close_x'], test_data['close_y'])
regress_output_1 = ss.get_regression_results({'y': test_data['close_y'].values, 'x': test_data['close_x'].values})
regress_output_2 = ss.get_regression_results({'y': training_data['close_y'].values, 'x': training_data['close_x'].values})
regress_output_3 = ss.get_regression_results({'y': test_data['close_y'].diff().values, 'x': test_data['close_x'].diff().values})
merged_data.set_index('settle_datetime', drop=True, inplace=True)
backtest_output_1 = backtest(merged_data[split:], 'close_x', 'close_y')
backtest_output_2 = backtest(merged_data[:split], 'close_x', 'close_y')
if get_diagnosticQ:
return {'backtest_output': backtest_output_1, 'cagr2': backtest_output_2['cagr']}
else:
return {'price1': merged_data['close_x'].iloc[-1],'price2': merged_data['close_y'].iloc[-1],
'p_value_2': cointegration_output_2[1],'p_value_1': cointegration_output_1[1],
'beta_1': regress_output_1['beta'], 'beta_2': regress_output_2['beta'],
'corr': np.sqrt(regress_output_3['rsquared']/100),
'cagr1': backtest_output_1['cagr'], 'cagr2': backtest_output_2['cagr'],
'kalpha': backtest_output_1['kalpha'], 'kbeta': backtest_output_1['kbeta'],
'meanSpread': backtest_output_1['meanSpread'], 'stdSpread': backtest_output_1['stdSpread'],
'zScore': backtest_output_1['zScore']}
def get_strategy_pnl(**kwargs):
alias = kwargs['alias']
con = msu.get_my_sql_connection(**kwargs)
strategy_info = ts.get_strategy_info_from_alias(alias=alias, con=con)
if 'as_of_date' in kwargs.keys():
as_of_date = kwargs['as_of_date']
else:
as_of_date = exp.doubledate_shift_bus_days()
if 'broker' in kwargs.keys():
broker = kwargs['broker']
else:
broker = 'abn'
open_date = int(strategy_info['open_date'].strftime('%Y%m%d'))
#open_date = 20160920
close_date = int(strategy_info['close_date'].strftime('%Y%m%d'))
if close_date > as_of_date:
close_date = as_of_date
bus_day_list = exp.get_bus_day_list(date_from=open_date,
date_to=close_date)
trades_frame = ts.get_trades_4strategy_alias(alias=alias, con=con)
if sum(trades_frame['instrument'] == 'S') > 0:
stock_strategy_Q = True
else:
stock_strategy_Q = False
if stock_strategy_Q:
return {
'pnl_frame': pd.DataFrame(),
'daily_pnl': np.nan,
'total_pnl': np.nan
}
unique_ticker_list = trades_frame['ticker'].unique()
stock_data_dictionary = {
x: gsp.get_stock_price_preloaded(ticker=x)
for x in unique_ticker_list
}
trades_frame['t_cost'] = [
smi.get_ib_t_cost(price=trades_frame['trade_price'].iloc[x],
quantity=trades_frame['trade_quantity'].iloc[x])
for x in range(len(trades_frame.index))
]
pnl_path = [
get_stock_strategy_pnl_4day(
alias=alias,
pnl_date=x,
con=con,
trades_frame=trades_frame,
stock_data_dictionary=stock_data_dictionary)
for x in bus_day_list
]
nan_price_q_list = [x['nan_price_q'] for x in pnl_path]
good_price_q_list = [not i for i in nan_price_q_list]
bus_day_after_nan_list = [
bus_day_list[x + 1] for x in range(len(bus_day_list) - 1)
if nan_price_q_list[x]
]
pnl_path = [
pnl_path[x] for x in range(len(pnl_path)) if good_price_q_list[x]
]
bus_day_list = [
bus_day_list[x] for x in range(len(bus_day_list))
if good_price_q_list[x]
]
# print(bus_day_list)
# print(bus_day_after_nan_list)
if len(bus_day_after_nan_list) > 0:
pnl_path_after_nan = [
get_stock_strategy_pnl_4day(
alias=alias,
pnl_date=x,
con=con,
trades_frame=trades_frame,
broker=broker,
shift_in_days=2,
stock_data_dictionary=stock_data_dictionary)
for x in bus_day_after_nan_list
]
for i in range(len(bus_day_after_nan_list)):
if bus_day_after_nan_list[i] in bus_day_list:
index_val = bus_day_list.index(bus_day_after_nan_list[i])
pnl_path[index_val] = pnl_path_after_nan[i]
pnl_frame = pd.DataFrame(pnl_path)
pnl_frame['settle_date'] = bus_day_list
output_dictionary = {
'pnl_frame':
pnl_frame[[
'settle_date', 'position_pnl', 'intraday_pnl', 't_cost',
'total_pnl'
]],
'daily_pnl':
pnl_frame['total_pnl'].values[-1],
'total_pnl':
pnl_frame['total_pnl'].sum()
}
else:
ticker_head_list = [
cmi.get_contract_specs(x)['ticker_head']
for x in trades_frame['ticker']
]
unique_ticker_head_list = list(set(ticker_head_list))
if 'futures_data_dictionary' in kwargs.keys():
futures_data_dictionary = kwargs['futures_data_dictionary']
else:
futures_data_dictionary = {
x: gfp.get_futures_price_preloaded(ticker_head=x)
for x in unique_ticker_head_list
}
trades_frame['contract_multiplier'] = [
cmi.contract_multiplier[x] for x in ticker_head_list
]
trades_frame['t_cost'] = [
cmi.get_t_cost(ticker_head=x, broker=broker)
for x in ticker_head_list
]
pnl_path = [
get_strategy_pnl_4day(
alias=alias,
pnl_date=x,
con=con,
trades_frame=trades_frame,
broker=broker,
futures_data_dictionary=futures_data_dictionary)
for x in bus_day_list
]
nan_price_q_list = [x['nan_price_q'] for x in pnl_path]
good_price_q_list = [not i for i in nan_price_q_list]
bus_day_after_nan_list = [
bus_day_list[x + 1] for x in range(len(bus_day_list) - 1)
if nan_price_q_list[x]
]
pnl_path = [
pnl_path[x] for x in range(len(pnl_path)) if good_price_q_list[x]
]
bus_day_list = [
bus_day_list[x] for x in range(len(bus_day_list))
if good_price_q_list[x]
]
#print(bus_day_list)
#print(bus_day_after_nan_list)
if len(bus_day_after_nan_list) > 0:
pnl_path_after_nan = [
get_strategy_pnl_4day(
alias=alias,
pnl_date=x,
con=con,
trades_frame=trades_frame,
broker=broker,
shift_in_days=2,
futures_data_dictionary=futures_data_dictionary)
for x in bus_day_after_nan_list
]
for i in range(len(bus_day_after_nan_list)):
index_val = bus_day_list.index(bus_day_after_nan_list[i])
pnl_path[index_val] = pnl_path_after_nan[i]
pnl_per_tickerhead_list = [x['pnl_per_tickerhead'] for x in pnl_path]
pnl_per_tickerhead = pd.concat(pnl_per_tickerhead_list,
axis=1,
sort=True)
pnl_per_tickerhead = pnl_per_tickerhead[['pnl_total']]
pnl_per_tickerhead = pnl_per_tickerhead.transpose()
if len(unique_ticker_head_list) > 1:
zero_indx = [[x not in y.index for y in pnl_per_tickerhead_list]
for x in pnl_per_tickerhead.columns]
for i in range(len(pnl_per_tickerhead.columns)):
pnl_per_tickerhead.iloc[:, i][zero_indx[i]] = 0
pnl_per_tickerhead['settle_date'] = bus_day_list
pnl_per_tickerhead.reset_index(inplace=True, drop=True)
pnl_frame = pd.DataFrame(pnl_path)
pnl_frame['settle_date'] = bus_day_list
daily_index = pnl_frame['settle_date'] == as_of_date
if sum(daily_index) == 0:
daily_pnl = np.nan
else:
daily_pnl = pnl_frame['total_pnl'].values[-1]
output_dictionary = {
'pnl_frame':
pnl_frame[[
'settle_date', 'position_pnl', 'intraday_pnl', 't_cost',
'total_pnl'
]],
'pnl_per_tickerhead':
pnl_per_tickerhead,
'daily_pnl':
daily_pnl,
'total_pnl':
pnl_frame['total_pnl'].sum()
}
if 'con' not in kwargs.keys():
con.close()
return output_dictionary
def get_stock_strategy_pnl_4day(**kwargs):
alias = kwargs['alias']
pnl_date = kwargs['pnl_date']
if 'shift_in_days' in kwargs.keys():
shift_in_days = kwargs['shift_in_days']
else:
shift_in_days = 1
pnl_datetime = cu.convert_doubledate_2datetime(pnl_date)
con = msu.get_my_sql_connection(**kwargs)
if 'trades_frame' in kwargs.keys():
trades_frame = kwargs['trades_frame']
else:
trades_frame = ts.get_trades_4strategy_alias(alias=alias, con=con)
trades_frame['t_cost'] = [
smi.get_ib_t_cost(price=trades_frame['trade_price'].iloc[x],
quantity=trades_frame['trade_quantity'].iloc[x])
for x in range(len(trades_frame.index))
]
position_frame_aux = trades_frame[
trades_frame['trade_date'] < pnl_datetime]
intraday_frame_aux = trades_frame[trades_frame['trade_date'] ==
pnl_datetime]
grouped = position_frame_aux.groupby(['ticker'])
net_position = pd.DataFrame()
net_position['qty'] = grouped['trade_quantity'].sum()
net_position['ticker'] = grouped['ticker'].first()
net_position = net_position[abs(net_position['qty']) > 0.1]
useful_generalized_ticker_list = list(
set(net_position['ticker'].values)
| set(intraday_frame_aux['ticker'].unique()))
trades_frame = trades_frame[trades_frame['ticker'].isin(
useful_generalized_ticker_list)]
if 'stock_data_dictionary' in kwargs.keys():
stock_data_dictionary = kwargs['stock_data_dictionary']
else:
unique_ticker_list = trades_frame['ticker'].unique()
stock_data_dictionary = {
x: gsp.get_stock_price_preloaded(ticker=x)
for x in unique_ticker_list
}
pnl_date_1 = exp.doubledate_shift_bus_days(double_date=pnl_date,
shift_in_days=shift_in_days)
stock_price_out_1 = [
gsp.get_stock_price_preloaded(
ticker=x,
stock_data_dictionary=stock_data_dictionary,
settle_date=pnl_date_1) for x in trades_frame['ticker']
]
stock_price_out = [
gsp.get_stock_price_preloaded(
ticker=x,
stock_data_dictionary=stock_data_dictionary,
settle_date=pnl_date) for x in trades_frame['ticker']
]
trades_frame['price_1'] = [
np.NaN if x.empty else x['close'].values[0] for x in stock_price_out_1
]
trades_frame['price'] = [
np.NaN if x.empty else x['close'].values[0] for x in stock_price_out
]
position_frame = trades_frame[trades_frame['trade_date'] < pnl_datetime]
nan_price_q = position_frame['price'].isnull().values.any()
intraday_frame = trades_frame[trades_frame['trade_date'] == pnl_datetime]
position_pnl_per_ticker = pd.DataFrame(columns=['ticker', 'pnl_position'])
intraday_pnl_per_ticker = pd.DataFrame(columns=['ticker', 'pnl_intraday'])
if len(position_frame) == 0:
position_pnl = 0
else:
position_frame['pnl'] = position_frame['trade_quantity'] * \
(position_frame['price'] - position_frame['price_1'])
position_pnl = position_frame['pnl'].sum()
position_grouped_per_ticker = position_frame.groupby('ticker')
position_pnl_per_ticker['pnl_position'] = (
position_grouped_per_ticker['pnl'].sum()).values
position_pnl_per_ticker['ticker'] = (
position_grouped_per_ticker['ticker'].first()).values
if len(intraday_frame) == 0:
intraday_pnl = 0
t_cost = 0
else:
intraday_frame['pnl'] = intraday_frame['trade_quantity'] * \
(intraday_frame['price'] - intraday_frame['trade_price'])
intraday_frame[
'pnl_wtcost'] = intraday_frame['pnl'] - intraday_frame['t_cost']
intraday_pnl = intraday_frame['pnl'].sum()
t_cost = intraday_frame['t_cost'].sum()
intraday_grouped_per_ticker = intraday_frame.groupby('ticker')
intraday_pnl_per_ticker['pnl_intraday'] = (
intraday_grouped_per_ticker['pnl_wtcost'].sum()).values
intraday_pnl_per_ticker['ticker'] = (
intraday_grouped_per_ticker['ticker'].first()).values
pnl_per_ticker = pd.merge(position_pnl_per_ticker,
intraday_pnl_per_ticker,
how='outer',
on='ticker')
intraday_zero_indx = [
x not in intraday_pnl_per_ticker['ticker'].values
for x in pnl_per_ticker['ticker']
]
position_zero_indx = [
x not in position_pnl_per_ticker['ticker'].values
for x in pnl_per_ticker['ticker']
]
pnl_per_ticker['pnl_position'][position_zero_indx] = 0
pnl_per_ticker['pnl_intraday'][intraday_zero_indx] = 0
pnl_per_ticker['pnl_total'] = pnl_per_ticker[
'pnl_position'] + pnl_per_ticker['pnl_intraday']
pnl_per_ticker.set_index('ticker', drop=True, inplace=True)
if 'con' not in kwargs.keys():
con.close()
return {
'total_pnl': int(position_pnl + intraday_pnl - t_cost),
'position_pnl': int(position_pnl),
'intraday_pnl': int(intraday_pnl),
't_cost': int(t_cost),
'nan_price_q': nan_price_q,
'pnl_per_ticker': pnl_per_ticker
}
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_tms(**kwargs):
date_to = kwargs['date_to']
feature_list = ['obv', 'rsi_6', 'rsi_12', 'atr_14', 'mfi_14',
'adx_14', 'adx_20', 'rocr_1', 'rocr_3', 'rocr_12', 'cci_12', 'cci_20',
'macd_12_26', 'macd_signal_12_26_9', 'macd_hist_12_26_9',
'williams_r_10', 'tsf_10_3', 'tsf_20_3', 'trix_15']
if 'ticker_head' in kwargs.keys():
ticker_head = kwargs['ticker_head']
panel_data = gfp.get_futures_price_preloaded(ticker_head=ticker_head, settle_date_to=date_to,
settle_date_from=cu.doubledate_shift(date_to, 11 * 365))
panel_data.rename(columns={'open_price': 'open', 'high_price': 'high', 'low_price': 'low', 'close_price': 'close'},inplace=True)
panel_data.sort_values(['cont_indx', 'settle_date'], ascending=[True, True], inplace=True)
unique_cont_indx_list = panel_data['cont_indx'].unique()
contract_data_list = []
for i in range(len(unique_cont_indx_list)):
contract_data = panel_data[panel_data['cont_indx'] == unique_cont_indx_list[i]]
if len(contract_data.index) < 30:
continue
contract_data = calc_tms(contract_data=contract_data)
contract_data_list.append(contract_data)
merged_frame = pd.concat(contract_data_list)
merged_frame.dropna(subset=feature_list, inplace=True)
merged_frame = merged_frame[merged_frame['cal_dte'] > 30]
merged_frame.sort_values(['settle_date', 'cont_indx'], ascending=[True, True], inplace=True)
data_out = merged_frame.drop_duplicates('settle_date', inplace=False, keep='first')
elif 'stock_ticker' in kwargs.keys():
contract_data = gsp.get_stock_price_preloaded(ticker='AAPL', settle_date_to=date_to,
settle_date_from=cu.doubledate_shift(date_to, 11 * 365))
contract_data = contract_data[['close', 'settle_datetime', 'volume', 'high', 'low', 'split_coefficient']]
contract_data.reset_index(drop=True,inplace=True)
split_envents = contract_data[contract_data['split_coefficient'] != 1]
split_index_list = split_envents.index
for i in range(len(split_index_list)):
contract_data['close'].iloc[:split_index_list[i]] = \
contract_data['close'].iloc[:split_index_list[i]] / contract_data['split_coefficient'].iloc[split_index_list[i]]
contract_data['high'].iloc[:split_index_list[i]] = \
contract_data['high'].iloc[:split_index_list[i]] / contract_data['split_coefficient'].iloc[
split_index_list[i]]
contract_data['low'].iloc[:split_index_list[i]] = \
contract_data['low'].iloc[:split_index_list[i]] / contract_data['split_coefficient'].iloc[
split_index_list[i]]
contract_data.rename(columns={'settle_datetime': 'settle_date'}, inplace=True)
contract_data['change_1'] = contract_data.close - contract_data.close.shift(1)
data_out = calc_tms(contract_data=contract_data)
data_out.dropna(subset=feature_list, inplace=True)
return data_out
