def before_trading_start(context, data):
# Gets our pipeline output every day.
context.output = pipeline_output('my_pipeline')
context.stocks_worst = context.output[
context.output['stocks_worst']].index.tolist()
context.stocks_worst_weight = my_compute_weights(context)
context.MyCandidate = cycle(context.stocks_worst)
context.LowestPrice = context.MyLeastPrice # reset beginning of day
print(len(context.portfolio.positions))
for stock in context.portfolio.positions:
CurrPrice = float(data.current([stock], 'price'))
if CurrPrice < context.LowestPrice:
context.LowestPrice = CurrPrice
if stock in context.age:
context.age[stock] += 1
else:
context.age[stock] = 1
for stock in context.age:
if stock not in context.portfolio.positions:
context.age[stock] = 0
message = 'stock.symbol: {symbol} : age: {age}'
log.info(message.format(symbol=stock.symbol, age=context.age[stock]))
pass
def before_trading_start(context, data):
# over simplistic tracking of position age
if not hasattr(context, 'age') or not context.age:
context.age = {}
today = get_datetime().floor('1D')
last_date = getattr(context, 'last_date', None)
if today != last_date:
# Gets our pipeline output every day.
context.output = pipeline_output('my_pipeline')
context.stocks_worst = context.output[
context.output['stocks_worst']].index.tolist()
context.stocks_worst_weight = my_compute_weights(context)
context.MyCandidate = cycle(context.stocks_worst)
context.LowestPrice = context.MyLeastPrice # reset beginning of day
print(len(context.portfolio.positions))
for stock in context.portfolio.positions:
CurrPrice = float(data.current([stock], 'price'))
if CurrPrice < context.LowestPrice:
context.LowestPrice = CurrPrice
if stock in context.age:
context.age[stock] += 1
else:
context.age[stock] = 1
for stock in context.age:
if stock not in context.portfolio.positions:
context.age[stock] = 0
message = 'stock.symbol: {symbol} : age: {age}'
log.info(
message.format(symbol=stock.symbol, age=context.age[stock]))
context.last_date = today
def late_day_trade(context, data):
#Get the pipeline output
pipe_output = pipeline_output('Stocks')
context.days_stocks = pipe_output.sort_values(by =['ann_var'], ascending = False)
#log.info(context.days_stocks)
log.info(context.daily_message, context.day_count)
log.info(context.days_stocks)
log.info(type(context.days_stocks))
#Calculate Daily Return Top Losers
if (context.days_stocks.size > 0):
price_history = data.history(context.days_stocks.index, "price", 745, "1m") #356 +390
open_prices = price_history.iloc[0]
current_prices = price_history.iloc[-1]
context.idr_losers = ((current_prices - open_prices) / open_prices).sort_values()
context.idr_losers = context.idr_losers[0:5]#5
log.info(context.idr_losers)
else:
price_history = data.history(context.backup_stocks, "price", 1 , "1m") #356
current_prices = price_history.iloc[-1]
context.idr_losers = current_prices #Stock info is irrelevant here
pct_cash = context.portfolio.cash/context.portfolio.portfolio_value
#Get Open Orders and Buy
for stock in context.idr_losers.index:
if(data.can_trade(stock)):
if(stock not in context.open_orders):
order_target_percent(stock, pct_cash/(context.idr_losers.size + 1))
#Check Portfolio
#log.info(type(context.portfolio.positions))
record(leverage = context.account.leverage) #be sure to always track leverage
record(cash = context.portfolio.cash)
record(port_value = context.portfolio.portfolio_value)
def before_trading_start(context, data):
log.info("RUNNING before_trading_start")
# Prevent running more than once a day:
# https://docs.alpaca.markets/platform-migration/zipline-to-pylivetrader/#deal-with-restart
today = get_datetime().floor('1D')
last_date = getattr(context, 'last_date', None)
if today == last_date:
log.info(
"Skipping before_trading_start because it's already ran today")
return
context.output = pipeline_output('my_pipeline')
context.stocks_worst = context.output[
context.output['stocks_worst']].index.tolist()
context.MyCandidate = cycle(context.stocks_worst)
# Update ages
for stock in context.portfolio.positions:
if stock in context.age:
context.age[stock] += 1
else:
log.info("Could not find %s in context.age" % stock.symbol)
context.age[stock] = 1
# Remove stale ages
context.age = {
stock: age
for stock, age in context.age.items()
if stock not in context.portfolio.positions
}
# Track the last run
context.last_date = today
def before_trading_start(context, data):
prices = data.history(context.SPY, 'price', 21, '1d')
returns = prices.pct_change()
context.std_20 = round(returns.std() * np.sqrt(252), 2)
std_cutoff = context.std_cutoff
context.str_weight = np.where(context.std_20 > std_cutoff, 1, 0)
if context.str_weight == 0:
log.info(
'Vol {} is below {} threshold: Algorithm will hold S&P500'.format(
context.std_20, std_cutoff))
else:
log.info(
'Vol {} is above {} threshold: Algorithm will trade MARKET NEUTRAL PORTFOLIO'
.format(context.std_20, std_cutoff))
if context.flip_signal:
log.info('SIGNAL FLIPPED - ALGORITHM WILL TRADE TRADE MOMENTUM')
if context.ndays % context.idays == 0:
log.info('Algorithm will rebalance today')
log.info('Running Pipeline')
df = pipeline_output('pipeline')
df = df[(df.type == 'cs') | (df.type == 'ad')]
pa = df.dropna()
pa = pa.assign(ind_str=np.NaN)
pa = pa.assign(ind_adj_str=np.NaN)
pa['ind_str'] = pa[['str', 'ind']].groupby('ind').transform(
np.mean).values.flatten()
pa['ind_adj_str'] = pa['str'] / pa[[
'str', 'ind'
]].groupby('ind').transform(np.mean).values.flatten()
pipe_ind = pa
investable_industry_list = pipe_ind['ind'].value_counts()[
pipe_ind['ind'].value_counts() > 5].index.tolist()
context.pipe_out = pipe_ind[pipe_ind['ind'].isin(
investable_industry_list)]
log.info('Pipeline successfully run')
log.info('Prelim Longs: {}'.format(
context.pipe_out['ind_adj_str'].nsmallest(30).nlargest(15)))
log.info('Prelim Shorts: {}'.format(
context.pipe_out['ind_adj_str'].nlargest(15)))
log.info('Algorithm ready to trade')
else:
log.info(
'Algorithm last run {} days ago and will not run today'.format(
context.ndays))
def before_trading_start(context, data):
# Clear the list of todays orders and start fresh
# Would like to do this 'context.today_orders.clear()' but not supported
del context.todays_orders[:]
# Get the dataframe
context.output = pipeline_output('my_pipeline')
# Add other columns to the dataframe for storing qty of shares held, etc
context.output = context.output.assign(
held_shares = 0,
target_shares = 0,
order_shares = 0,
target_value = 0.0,
order_value = 0.0,
weight = context.MY_ETFS.weight,
last_price = 0.0
)
def before_trading_start(context, data):
log.info("RUNNING before_trading_start")
# Prevent running more than once a day:
# https://docs.alpaca.markets/platform-migration/zipline-to-pylivetrader/#deal-with-restart
today = get_datetime().floor('1D')
last_date = getattr(context, 'last_date', None)
if today == last_date:
log.info("Skipping before_trading_start because it's already ran today")
return
pipe_results = pipeline_output('my_pipeline')
log.info(pipe_results)
context.longs = []
for sec in pipe_results[pipe_results['longs']].index.tolist():
context.longs.append(sec)
context.shorts = []
for sec in pipe_results[pipe_results['shorts']].index.tolist():
context.shorts.append(sec)
# Track the last run
context.last_date = today
def format_pipeline():
"""Restructure pipeline data and add factors that could not
be calculated within the pipeline."""
pipe_out = pipeline_output('pipeline')
pipe_out = pipe_out[(pipe_out.type == 'cs') | (pipe_out.type == 'ad')]
pipe_format = pipe_out
pipe_format = pipe_format[pipe_format['bab_t01'] > 0]
momcols = ['mom12_t01', 'mom12_t02', 'mom12_t03', 'mom12_t04', 'mom12_t05',
'mom12_t06', 'mom12_t07', 'mom12_t08', 'mom12_t09', 'mom12_t10']
momcoldf = pipe_format[momcols]
momcoldf = momcoldf.apply(lambda x: x.fillna(x.mean()),axis=1)
pipe_format.drop(momcols, axis='columns', inplace=True)
pipe_format[momcols] = momcoldf[momcols]
pipe_format = pipe_format.dropna()
raw_pipe = pipe_format
didx = pipe_format.index
pipe_format = pipe_format.assign(istr_t01=cf.compute_istr(pipe_format, 'sstr_t01'),
istr_t02=cf.compute_istr(pipe_format, 'sstr_t02'),
istr_t03=cf.compute_istr(pipe_format, 'sstr_t03'),
istr_t04=cf.compute_istr(pipe_format, 'sstr_t04'),
istr_t05=cf.compute_istr(pipe_format, 'sstr_t05'),
istr_t06=cf.compute_istr(pipe_format, 'sstr_t06'),
istr_t07=cf.compute_istr(pipe_format, 'sstr_t07'),
istr_t08=cf.compute_istr(pipe_format, 'sstr_t08'),
istr_t09=cf.compute_istr(pipe_format, 'sstr_t09'),
istr_t10=cf.compute_istr(pipe_format, 'sstr_t10'))
pipe_format = pipe_format.assign(iret_t01=cf.compute_iret(pipe_format, 'sstr_t01'),
iret_t02=cf.compute_iret(pipe_format, 'sstr_t02'),
iret_t03=cf.compute_iret(pipe_format, 'sstr_t03'),
iret_t04=cf.compute_iret(pipe_format, 'sstr_t04'),
iret_t05=cf.compute_iret(pipe_format, 'sstr_t05'),
iret_t06=cf.compute_iret(pipe_format, 'sstr_t06'),
iret_t07=cf.compute_iret(pipe_format, 'sstr_t07'),
iret_t08=cf.compute_iret(pipe_format, 'sstr_t08'),
iret_t09=cf.compute_iret(pipe_format, 'sstr_t09'),
iret_t10=cf.compute_iret(pipe_format, 'sstr_t10'))
pipe_format.index = didx
ind_count = pipe_format.groupby(['ind']).ind.transform('size').values
pipe_format = pipe_format.assign(ind_count = ind_count)
pipe_format = pipe_format[pipe_format.ind_count > 5]
pipe_format = pipe_format.drop(['ind_count'], axis=1)
frame = pipe_format
pipe_format = pipe_format.drop(['ind', 'type', 'symbol'], axis=1)
# Standardize Columns
pipe_format = pipe_format.apply(lambda x: (x - np.nanmean(x)) / (np.nanstd(x)))
spy_rets = get_rets('SPY', 30)
pipe_format = pipe_format.assign(std_t01=np.log(spy_rets[-20:].std()*np.sqrt(252))+2,
std_t02=np.log(spy_rets[-21:-1].std()*np.sqrt(252))+2,
std_t03=np.log(spy_rets[-22:-2].std()*np.sqrt(252))+2,
std_t04=np.log(spy_rets[-23:-3].std()*np.sqrt(252))+2,
std_t05=np.log(spy_rets[-24:-4].std()*np.sqrt(252))+2,
std_t06=np.log(spy_rets[-25:-5].std()*np.sqrt(252))+2,
std_t07=np.log(spy_rets[-26:-6].std()*np.sqrt(252))+2,
std_t08=np.log(spy_rets[-27:-7].std()*np.sqrt(252))+2,
std_t09=np.log(spy_rets[-28:-8].std()*np.sqrt(252))+2,
std_t10=np.log(spy_rets[-29:-9].std()*np.sqrt(252))+2)
col_names = ['bab_t01', 'bab_t02', 'bab_t03', 'bab_t04', 'bab_t05',
'bab_t06', 'bab_t07', 'bab_t08', 'bab_t09', 'bab_t10',
'iret_t01', 'iret_t02', 'iret_t03', 'iret_t04', 'iret_t05',
'iret_t06', 'iret_t07', 'iret_t08', 'iret_t09', 'iret_t10',
'istr_t01', 'istr_t02', 'istr_t03', 'istr_t04', 'istr_t05',
'istr_t06', 'istr_t07', 'istr_t08', 'istr_t09', 'istr_t10',
'mom12_t01', 'mom12_t02', 'mom12_t03', 'mom12_t04', 'mom12_t05',
'mom12_t06', 'mom12_t07', 'mom12_t08', 'mom12_t09', 'mom12_t10',
'sstr_t01', 'sstr_t02', 'sstr_t03', 'sstr_t04', 'sstr_t05',
'sstr_t06', 'sstr_t07', 'sstr_t08', 'sstr_t09', 'sstr_t10',
'std_t01', 'std_t02', 'std_t03', 'std_t04', 'std_t05',
'std_t06', 'std_t07', 'std_t08', 'std_t09', 'std_t10']
pipe_format = pipe_format.reindex(columns=col_names)
clip1 = ['bab_t01', 'bab_t02', 'bab_t03', 'bab_t04', 'bab_t05',
'bab_t06', 'bab_t07', 'bab_t08', 'bab_t09', 'bab_t10']
clip2 = ['sstr_t01', 'sstr_t02', 'sstr_t03', 'sstr_t04', 'sstr_t05',
'sstr_t06', 'sstr_t07', 'sstr_t08', 'sstr_t09', 'sstr_t10',
'istr_t01', 'istr_t02', 'istr_t03', 'istr_t04', 'istr_t05',
'istr_t06', 'istr_t07', 'istr_t08', 'istr_t09', 'istr_t10']
clip3 = ['iret_t01', 'iret_t02', 'iret_t03', 'iret_t04', 'iret_t05',
'iret_t06', 'iret_t07', 'iret_t08', 'iret_t09', 'iret_t10',
'mom12_t01', 'mom12_t02', 'mom12_t03', 'mom12_t04', 'mom12_t05',
'mom12_t06', 'mom12_t07', 'mom12_t08', 'mom12_t09', 'mom12_t10']
pipe_format = pipe_format.apply(lambda x: np.clip(x, -1, 1) if x.name in clip1 else x)
pipe_format = pipe_format.apply(lambda x: np.clip(x, -2, 2) if x.name in clip2 else x)
pipe_format = pipe_format.apply(lambda x: np.clip(x, -3, 3) if x.name in clip3 else x)
pipe_final = pipe_format
return pipe_final, frame, raw_pipe
def format_pipeline(context, data):
df = pipeline_output('pipeline')
df = df[(df.type == 'cs') | (df.type == 'ad')]
d = df
d = d[d['bab_t01'] > 0]
didx = d.index
def ComputeISTR(str_col, ind_col='ind'):
Data_stock = d[[str_col, 'ind']]
Data_stock.columns = ['STR', 'ind']
Data_industry = pd.DataFrame(index=Data_stock.index,
data={
"STR_ind":
Data_stock.groupby("ind").transform(
np.mean).values.flatten()
})
istr = Data_stock["STR"] / Data_industry["STR_ind"]
return istr
d = d.assign(istr_t01=ComputeISTR('sstr_t01'))
d = d.assign(istr_t02=ComputeISTR('sstr_t02'))
d = d.assign(istr_t03=ComputeISTR('sstr_t03'))
d = d.assign(istr_t04=ComputeISTR('sstr_t04'))
d = d.assign(istr_t05=ComputeISTR('sstr_t05'))
d = d.assign(istr_t06=ComputeISTR('sstr_t06'))
d = d.assign(istr_t07=ComputeISTR('sstr_t07'))
d = d.assign(istr_t08=ComputeISTR('sstr_t08'))
d = d.assign(istr_t09=ComputeISTR('sstr_t09'))
d = d.assign(istr_t10=ComputeISTR('sstr_t10'))
def ComputeIRet(str_col, ind_col='ind'):
Data_stock = d[[str_col, 'ind']]
Data_stock.columns = ['STR', 'ind']
Data_industry = pd.DataFrame(index=Data_stock.index,
data={
"ret_ind":
Data_stock.groupby("ind").transform(
np.mean).values.flatten()
})
iret = Data_industry["ret_ind"]
return iret
d = d.assign(iret_t01=ComputeIRet('sstr_t01'))
d = d.assign(iret_t02=ComputeIRet('sstr_t02'))
d = d.assign(iret_t03=ComputeIRet('sstr_t03'))
d = d.assign(iret_t04=ComputeIRet('sstr_t04'))
d = d.assign(iret_t05=ComputeIRet('sstr_t05'))
d = d.assign(iret_t06=ComputeIRet('sstr_t06'))
d = d.assign(iret_t07=ComputeIRet('sstr_t07'))
d = d.assign(iret_t08=ComputeIRet('sstr_t08'))
d = d.assign(iret_t09=ComputeIRet('sstr_t09'))
d = d.assign(iret_t10=ComputeIRet('sstr_t10'))
def get_pb():
quandl.ApiConfig.api_key = "xqLBtxUAuiSBxaR3rXxw"
today = datetime.today()
daily_data_date = (today - timedelta(25)).strftime('%Y-%m-%d')
data = quandl.get_table('SHARADAR/DAILY',
paginate=True,
date={'gte': daily_data_date},
qopts={'columns': ['date', 'ticker', 'pb']})
dates = list(pd.Series(data.date.unique()).nlargest(10))
data = data[data.date.isin(dates)]
arrays = [np.array(data.date), np.array(data.ticker.values)]
midx = pd.MultiIndex.from_arrays(arrays, names=('date', 'ticker'))
data = data.set_index(midx)
data.sort_index(inplace=True, ascending=True)
data = data.drop(['date', 'ticker'], axis=1)
data = data.rename(
columns={'ticker':
'symbol'}) #### Check if this needs to be set to data =
pbdf = data.unstack(level=0)
pb_cols = [
'pb_t10', 'pb_t09', 'pb_t08', 'pb_t07', 'pb_t06', 'pb_t05',
'pb_t04', 'pb_t03', 'pb_t02', 'pb_t01'
]
pbdf.columns = pb_cols
pbdf = np.log(pbdf)
pbdf['symbol'] = pbdf.index
return pbdf
pbdf = get_pb()
d = d.merge(pbdf, left_index=True, how='left', on='symbol')
def get_qmj():
today = datetime.today()
daily_data_date = (today - timedelta(100)).strftime('%Y-%m-%d')
data_list = []
cursor_id = None
while True:
data = quandl.Datatable('SHARADAR/SF1').data(
params={
'dimension': 'ARQ',
'datekey': {
'gte': daily_data_date
},
'qopts': {
'columns':
['datekey', 'ticker', 'revenue', 'cor', 'assets']
}
})
cursor_id = data.meta['next_cursor_id']
data_list.append(data)
if cursor_id is None:
break
data = data.to_pandas()
data = data.loc[data.groupby('ticker').datekey.idxmax(), :]
data['qmj'] = (data.revenue - data.cor) / data.assets
qmj = data.qmj**(1 / 3)
data.qmj = qmj
data.index = data['ticker'].values
data = data.drop(['datekey', 'revenue', 'cor', 'assets'], axis=1)
data = data.rename(columns={'ticker': 'symbol'})
qmjdf = pd.DataFrame(index=data.symbol,
data={
'qmj_t01': data.qmj,
'qmj_t02': data.qmj,
'qmj_t03': data.qmj,
'qmj_t04': data.qmj,
'qmj_t05': data.qmj,
'qmj_t06': data.qmj,
'qmj_t07': data.qmj,
'qmj_t08': data.qmj,
'qmj_t09': data.qmj,
'qmj_t10': data.qmj,
'symbol': data.symbol
})
return qmjdf
qmjdf = get_qmj()
d = d.merge(qmjdf, left_index=True, how='left', on='symbol')
d.index = didx
d = d.dropna()
frame = d
symbol_map = d.symbol
ind_map = d.ind
d = d.drop(['ind', 'type', 'symbol'], axis=1)
# Standardize Columns
d = d.apply(lambda x: (x - np.nanmean(x)) / (np.nanstd(x)))
"""
def get_rets(symbol, ndays):
today = datetime.today()
current = today.strftime("%Y-%m-%d")
cal_days = ndays*2
past = (today - timedelta(days=cal_days)).strftime("%Y-%m-%d")
price_df = api.polygon.historic_agg_v2(symbol=symbol,
multiplier=1,
timespan='day',
_from=past,
to=current).df
price_rets = price_df.close.pct_change()
price_rets = price_rets[-ndays:]
return price_rets
"""
spy_rets = get_rets('SPY', 30)
d = d.assign(std_t01=np.log(spy_rets[-20:].std() * np.sqrt(252)) + 2)
d = d.assign(std_t02=np.log(spy_rets[-21:-1].std() * np.sqrt(252)) + 2)
d = d.assign(std_t03=np.log(spy_rets[-22:-2].std() * np.sqrt(252)) + 2)
d = d.assign(std_t04=np.log(spy_rets[-23:-3].std() * np.sqrt(252)) + 2)
d = d.assign(std_t05=np.log(spy_rets[-24:-4].std() * np.sqrt(252)) + 2)
d = d.assign(std_t06=np.log(spy_rets[-25:-5].std() * np.sqrt(252)) + 2)
d = d.assign(std_t07=np.log(spy_rets[-26:-6].std() * np.sqrt(252)) + 2)
d = d.assign(std_t08=np.log(spy_rets[-27:-7].std() * np.sqrt(252)) + 2)
d = d.assign(std_t09=np.log(spy_rets[-28:-8].std() * np.sqrt(252)) + 2)
d = d.assign(std_t10=np.log(spy_rets[-29:-9].std() * np.sqrt(252)) + 2)
col_names = [
'bab_t01', 'bab_t02', 'bab_t03', 'bab_t04', 'bab_t05', 'bab_t06',
'bab_t07', 'bab_t08', 'bab_t09', 'bab_t10', 'iret_t01', 'iret_t02',
'iret_t03', 'iret_t04', 'iret_t05', 'iret_t06', 'iret_t07', 'iret_t08',
'iret_t09', 'iret_t10', 'istr_t01', 'istr_t02', 'istr_t03', 'istr_t04',
'istr_t05', 'istr_t06', 'istr_t07', 'istr_t08', 'istr_t09', 'istr_t10',
'mom12_t01', 'mom12_t02', 'mom12_t03', 'mom12_t04', 'mom12_t05',
'mom12_t06', 'mom12_t07', 'mom12_t08', 'mom12_t09', 'mom12_t10',
'pb_t01', 'pb_t02', 'pb_t03', 'pb_t04', 'pb_t05', 'pb_t06', 'pb_t07',
'pb_t08', 'pb_t09', 'pb_t10', 'qmj_t01', 'qmj_t02', 'qmj_t03',
'qmj_t04', 'qmj_t05', 'qmj_t06', 'qmj_t07', 'qmj_t08', 'qmj_t09',
'qmj_t10', 'sstr_t01', 'sstr_t02', 'sstr_t03', 'sstr_t04', 'sstr_t05',
'sstr_t06', 'sstr_t07', 'sstr_t08', 'sstr_t09', 'sstr_t10', 'std_t01',
'std_t02', 'std_t03', 'std_t04', 'std_t05', 'std_t06', 'std_t07',
'std_t08', 'std_t09', 'std_t10'
]
d = d.reindex(columns=col_names)
d["sstr_t01"].clip(-3, 3, inplace=True)
d["sstr_t02"].clip(-3, 3, inplace=True)
d["sstr_t03"].clip(-3, 3, inplace=True)
d["sstr_t04"].clip(-3, 3, inplace=True)
d["sstr_t05"].clip(-3, 3, inplace=True)
d["sstr_t06"].clip(-3, 3, inplace=True)
d["sstr_t07"].clip(-3, 3, inplace=True)
d["sstr_t08"].clip(-3, 3, inplace=True)
d["sstr_t09"].clip(-3, 3, inplace=True)
d["sstr_t10"].clip(-3, 3, inplace=True)
d['istr_t01'].clip(-3, 3, inplace=True)
d['istr_t02'].clip(-3, 3, inplace=True)
d['istr_t03'].clip(-3, 3, inplace=True)
d['istr_t04'].clip(-3, 3, inplace=True)
d['istr_t05'].clip(-3, 3, inplace=True)
d['istr_t06'].clip(-3, 3, inplace=True)
d['istr_t07'].clip(-3, 3, inplace=True)
d['istr_t08'].clip(-3, 3, inplace=True)
d['istr_t09'].clip(-3, 3, inplace=True)
d['istr_t10'].clip(-3, 3, inplace=True)
d['iret_t01'].clip(-3, 3, inplace=True)
d['iret_t02'].clip(-3, 3, inplace=True)
d['iret_t03'].clip(-3, 3, inplace=True)
d['iret_t04'].clip(-3, 3, inplace=True)
d['iret_t05'].clip(-3, 3, inplace=True)
d['iret_t06'].clip(-3, 3, inplace=True)
d['iret_t07'].clip(-3, 3, inplace=True)
d['iret_t08'].clip(-3, 3, inplace=True)
d['iret_t09'].clip(-3, 3, inplace=True)
d['iret_t10'].clip(-3, 3, inplace=True)
d['mom12_t01'].clip(-4, 4, inplace=True)
d['mom12_t02'].clip(-4, 4, inplace=True)
d['mom12_t03'].clip(-4, 4, inplace=True)
d['mom12_t04'].clip(-4, 4, inplace=True)
d['mom12_t05'].clip(-4, 4, inplace=True)
d['mom12_t06'].clip(-4, 4, inplace=True)
d['mom12_t07'].clip(-4, 4, inplace=True)
d['mom12_t08'].clip(-4, 4, inplace=True)
d['mom12_t09'].clip(-4, 4, inplace=True)
d['mom12_t10'].clip(-4, 4, inplace=True)
d['bab_t01'].clip(-1, 1, inplace=True)
d['bab_t02'].clip(-1, 1, inplace=True)
d['bab_t03'].clip(-1, 1, inplace=True)
d['bab_t04'].clip(-1, 1, inplace=True)
d['bab_t05'].clip(-1, 1, inplace=True)
d['bab_t06'].clip(-1, 1, inplace=True)
d['bab_t07'].clip(-1, 1, inplace=True)
d['bab_t08'].clip(-1, 1, inplace=True)
d['bab_t09'].clip(-1, 1, inplace=True)
d['bab_t10'].clip(-1, 1, inplace=True)
d['pb_t01'].clip(-4, 4, inplace=True)
d['pb_t02'].clip(-4, 4, inplace=True)
d['pb_t03'].clip(-4, 4, inplace=True)
d['pb_t04'].clip(-4, 4, inplace=True)
d['pb_t05'].clip(-4, 4, inplace=True)
d['pb_t06'].clip(-4, 4, inplace=True)
d['pb_t07'].clip(-4, 4, inplace=True)
d['pb_t08'].clip(-4, 4, inplace=True)
d['pb_t09'].clip(-4, 4, inplace=True)
d['pb_t10'].clip(-4, 4, inplace=True)
d['qmj_t01'].clip(-4, 4, inplace=True)
d['qmj_t02'].clip(-4, 4, inplace=True)
d['qmj_t03'].clip(-4, 4, inplace=True)
d['qmj_t04'].clip(-4, 4, inplace=True)
d['qmj_t05'].clip(-4, 4, inplace=True)
d['qmj_t06'].clip(-4, 4, inplace=True)
d['qmj_t07'].clip(-4, 4, inplace=True)
d['qmj_t08'].clip(-4, 4, inplace=True)
d['qmj_t09'].clip(-4, 4, inplace=True)
d['qmj_t10'].clip(-4, 4, inplace=True)
df = d
return df, symbol_map, ind_map, frame
def before_trading_start(context, data):
log.debug("Running before trading starts")
context.my_output = pipeline_output('my_pipeline')
prepare_candidates(context, data)
log.debug("Done running before trading starts")
def format_pipeline(context, data):
df = pipeline_output('pipeline')
df = df[(df.type == 'cs') | (df.type == 'ad')]
d = df
d = d[d['bab_t01'] > 0]
def ComputeISTR(str_col, ind_col='ind'):
Data_stock = d[[str_col, 'ind']]
Data_stock.columns = ['STR', 'ind']
Data_industry = pd.DataFrame(index=Data_stock.index,
data={
"STR_ind":
Data_stock.groupby("ind").transform(
np.mean).values.flatten()
})
istr = Data_stock["STR"] / Data_industry["STR_ind"]
return istr
d = d.assign(istr_t01=ComputeISTR('sstr_t01'))
d = d.assign(istr_t02=ComputeISTR('sstr_t02'))
d = d.assign(istr_t03=ComputeISTR('sstr_t03'))
d = d.assign(istr_t04=ComputeISTR('sstr_t04'))
d = d.assign(istr_t05=ComputeISTR('sstr_t05'))
d = d.assign(istr_t06=ComputeISTR('sstr_t06'))
d = d.assign(istr_t07=ComputeISTR('sstr_t07'))
d = d.assign(istr_t08=ComputeISTR('sstr_t08'))
d = d.assign(istr_t09=ComputeISTR('sstr_t09'))
d = d.assign(istr_t10=ComputeISTR('sstr_t10'))
def ComputeIRet(str_col, ind_col='ind'):
Data_stock = d[[str_col, 'ind']]
Data_stock.columns = ['STR', 'ind']
Data_industry = pd.DataFrame(index=Data_stock.index,
data={
"ret_ind":
Data_stock.groupby("ind").transform(
np.mean).values.flatten()
})
iret = Data_industry["ret_ind"]
return iret
d = d.assign(iret_t01=ComputeIRet('sstr_t01'))
d = d.assign(iret_t02=ComputeIRet('sstr_t02'))
d = d.assign(iret_t03=ComputeIRet('sstr_t03'))
d = d.assign(iret_t04=ComputeIRet('sstr_t04'))
d = d.assign(iret_t05=ComputeIRet('sstr_t05'))
d = d.assign(iret_t06=ComputeIRet('sstr_t06'))
d = d.assign(iret_t07=ComputeIRet('sstr_t07'))
d = d.assign(iret_t08=ComputeIRet('sstr_t08'))
d = d.assign(iret_t09=ComputeIRet('sstr_t09'))
d = d.assign(iret_t10=ComputeIRet('sstr_t10'))
d = d.dropna()
frame = d
symbol_map = d.symbol
ind_map = d.ind
d = d.drop(['ind', 'type', 'symbol'], axis=1)
# Standardize Columns
d = d.apply(lambda x: (x - np.nanmean(x)) / (np.nanstd(x)))
def get_rets(symbol, ndays):
today = datetime.today()
current = today.strftime("%Y-%m-%d")
cal_days = ndays * 2
past = (today - timedelta(days=cal_days)).strftime("%Y-%m-%d")
price_df = api.polygon.historic_agg_v2(symbol=symbol,
multiplier=1,
timespan='day',
_from=past,
to=current).df
price_rets = price_df.close.pct_change()
price_rets = price_rets[-ndays:]
return price_rets
spy_rets = get_rets('SPY', 30)
d = d.assign(std_t01=np.log(spy_rets[-20:].std() * np.sqrt(252)) + 2)
d = d.assign(std_t02=np.log(spy_rets[-21:-1].std() * np.sqrt(252)) + 2)
d = d.assign(std_t03=np.log(spy_rets[-22:-2].std() * np.sqrt(252)) + 2)
d = d.assign(std_t04=np.log(spy_rets[-23:-3].std() * np.sqrt(252)) + 2)
d = d.assign(std_t05=np.log(spy_rets[-24:-4].std() * np.sqrt(252)) + 2)
d = d.assign(std_t06=np.log(spy_rets[-25:-5].std() * np.sqrt(252)) + 2)
d = d.assign(std_t07=np.log(spy_rets[-26:-6].std() * np.sqrt(252)) + 2)
d = d.assign(std_t08=np.log(spy_rets[-27:-7].std() * np.sqrt(252)) + 2)
d = d.assign(std_t09=np.log(spy_rets[-28:-8].std() * np.sqrt(252)) + 2)
d = d.assign(std_t10=np.log(spy_rets[-29:-9].std() * np.sqrt(252)) + 2)
col_names = [
'bab_t01', 'bab_t02', 'bab_t03', 'bab_t04', 'bab_t05', 'bab_t06',
'bab_t07', 'bab_t08', 'bab_t09', 'bab_t10', 'iret_t01', 'iret_t02',
'iret_t03', 'iret_t04', 'iret_t05', 'iret_t06', 'iret_t07', 'iret_t08',
'iret_t09', 'iret_t10', 'istr_t01', 'istr_t02', 'istr_t03', 'istr_t04',
'istr_t05', 'istr_t06', 'istr_t07', 'istr_t08', 'istr_t09', 'istr_t10',
'mom12_t01', 'mom12_t02', 'mom12_t03', 'mom12_t04', 'mom12_t05',
'mom12_t06', 'mom12_t07', 'mom12_t08', 'mom12_t09', 'mom12_t10',
'sstr_t01', 'sstr_t02', 'sstr_t03', 'sstr_t04', 'sstr_t05', 'sstr_t06',
'sstr_t07', 'sstr_t08', 'sstr_t09', 'sstr_t10', 'std_t01', 'std_t02',
'std_t03', 'std_t04', 'std_t05', 'std_t06', 'std_t07', 'std_t08',
'std_t09', 'std_t10'
]
d = d.reindex(columns=col_names)
d["sstr_t01"].clip(-3, 3, inplace=True)
d["sstr_t02"].clip(-3, 3, inplace=True)
d["sstr_t03"].clip(-3, 3, inplace=True)
d["sstr_t04"].clip(-3, 3, inplace=True)
d["sstr_t05"].clip(-3, 3, inplace=True)
d["sstr_t06"].clip(-3, 3, inplace=True)
d["sstr_t07"].clip(-3, 3, inplace=True)
d["sstr_t08"].clip(-3, 3, inplace=True)
d["sstr_t09"].clip(-3, 3, inplace=True)
d["sstr_t10"].clip(-3, 3, inplace=True)
d['istr_t01'].clip(-3, 3, inplace=True)
d['istr_t02'].clip(-3, 3, inplace=True)
d['istr_t03'].clip(-3, 3, inplace=True)
d['istr_t04'].clip(-3, 3, inplace=True)
d['istr_t05'].clip(-3, 3, inplace=True)
d['istr_t06'].clip(-3, 3, inplace=True)
d['istr_t07'].clip(-3, 3, inplace=True)
d['istr_t08'].clip(-3, 3, inplace=True)
d['istr_t09'].clip(-3, 3, inplace=True)
d['istr_t10'].clip(-3, 3, inplace=True)
d['iret_t01'].clip(-3, 3, inplace=True)
d['iret_t02'].clip(-3, 3, inplace=True)
d['iret_t03'].clip(-3, 3, inplace=True)
d['iret_t04'].clip(-3, 3, inplace=True)
d['iret_t05'].clip(-3, 3, inplace=True)
d['iret_t06'].clip(-3, 3, inplace=True)
d['iret_t07'].clip(-3, 3, inplace=True)
d['iret_t08'].clip(-3, 3, inplace=True)
d['iret_t09'].clip(-3, 3, inplace=True)
d['iret_t10'].clip(-3, 3, inplace=True)
d['mom12_t01'].clip(-4, 4, inplace=True)
d['mom12_t02'].clip(-4, 4, inplace=True)
d['mom12_t03'].clip(-4, 4, inplace=True)
d['mom12_t04'].clip(-4, 4, inplace=True)
d['mom12_t05'].clip(-4, 4, inplace=True)
d['mom12_t06'].clip(-4, 4, inplace=True)
d['mom12_t07'].clip(-4, 4, inplace=True)
d['mom12_t08'].clip(-4, 4, inplace=True)
d['mom12_t09'].clip(-4, 4, inplace=True)
d['mom12_t10'].clip(-4, 4, inplace=True)
d['bab_t01'].clip(-1, 1, inplace=True)
d['bab_t02'].clip(-1, 1, inplace=True)
d['bab_t03'].clip(-1, 1, inplace=True)
d['bab_t04'].clip(-1, 1, inplace=True)
d['bab_t05'].clip(-1, 1, inplace=True)
d['bab_t06'].clip(-1, 1, inplace=True)
d['bab_t07'].clip(-1, 1, inplace=True)
d['bab_t08'].clip(-1, 1, inplace=True)
d['bab_t09'].clip(-1, 1, inplace=True)
d['bab_t10'].clip(-1, 1, inplace=True)
df = d
return df, symbol_map, ind_map, frame