def ensure_correctness():
d = get_pickle('tiingo', 'SPY')['SPY_AdjClose']
m = get_pickle('tiingo', 'SPY_1M', basic=False)['SPY_1M_AdjClose']
w = get_pickle('tiingo', 'SPY_1W', basic=False)['SPY_1W_AdjClose']
assert d.tail(1).values == m.tail(1).values == w.tail(
1).values, 'Ending resampled prices not match'
print(colored.green('Seems OK.'))
def see_portfolios():
data = get_pickle('tiingo', 'SPY')
data = normalize('tiingo', data)
bench = data['Adjusted_close'].pct_change()
ports = []
names = []
for p in PORTFOLIOS:
total_alloc = 0
print(p.name)
data['Adjusted_close'] = 0
data = data['Adjusted_close']
for s in p.alloc:
tmp = get_pickle('tiingo', s[0])
tmp = normalize('tiingo', tmp)
data += tmp['Adjusted_close'].pct_change() * s[1]
total_alloc += s[1]
ports.append(data)
names.append(p.name)
print(total_alloc)
df = concat(ports + [bench], axis=1).dropna()
df.columns = names + ['Benchmark']
df.cumsum().plot()
plt.show()
def reconstruct_returns(name, symbols):
fs = [f for f in listdir(join(STORAGE_PATH, 'portfolios', 'weights', 'returns')) if (name in f) & (f != '.gitkeep')]
adjfs = [f for f in listdir(join(STORAGE_PATH, 'portfolios', 'weights', 'adj_returns')) if (name in f) & (f != '.gitkeep')]
dfs = []
adjdfs = []
for f in fs:
_name = f.split('.')[0]
d = get_pickle(join('portfolios', 'weights', 'returns'), _name, as_is=True)
dfs.append(d)
for f in adjfs:
_name = f.split('.')[0]
d = get_pickle(join('portfolios', 'weights', 'adj_returns'), _name, as_is=True)
adjdfs.append(d)
df = concat(dfs, axis=1).sum(axis=1)
adjdf = concat(adjdfs, axis=1).sum(axis=1)
return df, adjdf, get_latest_allocs(name=name)
def latest_date_foreeach(symbols):
for s in symbols:
try:
d = get_pickle('tiingo', s)
ensure_latest(d, symbol=s)
except Exception as err:
print(colored.red('{}: {}'.format(s, err)))
def get_latest_allocs(name):
tot = len([f for f in listdir(join(STORAGE_PATH, 'portfolios', 'weights')) if (name in f) & (f != '.gitkeep')]) - 1
weights = get_pickle(join('portfolios', 'weights'), '{}_{}'.format(name, tot), as_is=True)
del weights['Returns']
del weights['Volatility']
del weights['Ratio']
return [weights.iloc[0].to_dict()]
def get_current_weights(SELECTED_PORTFOLIOS, SELECTED_STRATEGIES):
path = join('portfolios', 'tradeable')
fs = filenames(path, resampled=True)
fs += filenames(path, resampled=False)
selected = SELECTED_PORTFOLIOS + SELECTED_STRATEGIES
SELECTED_LST = [s['name'] for s in SELECTED_PORTFOLIOS] + [s['name'] for s in SELECTED_STRATEGIES]
res = []
total_weights = []
for f in fs:
name = f.split('.')[0]
if name in SELECTED_LST:
d = get_pickle(path, name, as_is=True)
for s in selected:
if s['name'] == name:
if s['type'] == 'cash':
arr = d * s['weight']
elif s['type'] == 'ports':
arr = d * s['weight'] / len([s['name'] for s in SELECTED_PORTFOLIOS if s['type'] == 'ports'])
elif s['type'] == 'strats':
arr = d * s['weight'] / len([s['name'] for s in SELECTED_STRATEGIES if s['type'] == 'strats'])
res.append(arr.T)
total_weights += list(arr.values[0])
out = concat(res, axis=0)
out.columns = ['W']
out = out.groupby(out.index).sum()
assert round(sum(total_weights), 2) == 1.0, 'Total index weights are not equal 100%!'
print('% Weights')
print(out)
print('$ Weights')
print(round(out * 100000, 2)) # Use defined capital if not via Trader API
def pickle_to_csv_all(folder='tiingo'):
fs = filenames(folder)
for f in fs:
if '.p' in f:
try:
name = f.split('.')[0]
df = get_pickle(folder, name)
df.to_csv(join(STORAGE_PATH, folder, '{}.csv'.format(name)))
print(colored.green('Converted {}'.format(name)))
except Exception as err:
print(colored.red(err))
def coinapi_collect_all_coins(api):
coins = get_pickle('coinapi', 'symbols')
filtered_coins = coins.loc[coins['symbol_type'] == 'SPOT'].loc[
coins['exchange_id'] == 'BITTREX'].reset_index()
for i in range(0, len(filtered_coins)):
d = filtered_coins.ix[i]['data_start'].split('-')
start_data = date(int(d[0]), int(d[1]), int(d[2])).isoformat()
conapi_data(api=api,
symbol_id=filtered_coins.ix[i]['symbol_id'],
period='1HRS',
start_data=start_data)
print('{}/{}'.format(i, len(filtered_coins)))
def run_bt_multiple():
cerebro = Cerebro()
df = get_pickle('tiingo', 'SPY')
data = PandasData(dataname=df)
cerebro.adddata(data)
cerebro.addanalyzer(Returns)
cerebro.optstrategy(StrategyFetcher, idx=[0, 1])
results = cerebro.run()
strats = [x[0] for x in results]
for i, strat in enumerate(strats):
rets = strat.analyzers.returns.get_analysis()
print('Strategy {} Name {}:\n - analyzer: {}\n'.format(
i, strat.__class__.__name__, rets))
def resample_all(folder='tiingo'):
pers = ['1W', '1M']
symbols = [
f.split('.')[0] for f in filenames(folder)
if (('.p' in f) & ('_' not in f))
]
for s in symbols:
try:
df = get_pickle(folder=folder, name=s, resampler=True)
for p in pers:
df = resample_df(folder=folder, df=df, period=p)
write_resampled_df(df=df, folder=folder, s=s, p=p)
except Exception as err:
print(colored.red(err))
def compare(val, title, lim=None):
df = get_pickle('tiingo', 'SPY')
market = df['SPY_AdjClose'].pct_change().cumsum()
if lim is not None:
market = market.loc[lim:]
fig = plt.figure(figsize=(16,10))
ax1 = fig.add_subplot(111)
ax1.plot(val, color=BLUE1)
ax1.set_ylabel('Indicator')
ax2 = ax1.twinx()
ax2.plot(market, 'r-')
ax2.set_ylabel('S&P500', color='r')
for tl in ax2.get_yticklabels():
tl.set_color('r')
plt.title(title)
return plt
def run_alpha_strategy(model):
try:
model = int(model)
except:
model = None
pass
BASKET = BASKETS[1].symbols
initial = get_pickle(DATA_SOURCE, BASKET[0])
initial = transform_multi_data(data=initial, symbol=BASKET[0])
data = join_data(primary=initial, folder=DATA_SOURCE, symbols=BASKET[1:])
data = clean_prices(data=data, symbols=BASKET, d_type='eod')
if model is None:
for i in all_alphas():
print('Alpha %s' % i)
run_factor(data, i, BASKET)
else:
run_factor(data, model, BASKET)
def portfolio_returns(data, adj_data, symbols, name, comms, min_var=False):
weights = get_pickle(join('portfolios', 'weights'), name, as_is=True)
if min_var:
best_ratio = weights.loc[weights['Volatility'] == weights['Volatility'].min()]
best_ratio = weights.iloc[0]
data['combined'] = 0
adj_data['adj_combined'] = 0
w = 0
for s in symbols:
w += best_ratio['{}'.format(s)]
filtered_comms = comms[s].fillna(0.0) / len(comms[s].index) * 2
data['comm'] = filtered_comms
data['combined'] += best_ratio['{}'.format(s)] * data['{}_ret'.format(s)] - best_ratio['{}'.format(s)] * data['comm']
adj_data['adj_combined'] += best_ratio['{}'.format(s)] * adj_data['{}_ret'.format(s)] - best_ratio['{}'.format(s)] * data['comm']
assert round(w, 2) == 1.0, 'Allocations {}'.format(w)
data['combined'].to_pickle(join(STORAGE_PATH, 'portfolios', 'weights', 'returns', '{}.p'.format(name)))
adj_data['adj_combined'].to_pickle(join(STORAGE_PATH, 'portfolios', 'weights', 'adj_returns', '{}.p'.format(name)))
def optimize(data, r, op, factor='sortino', rev=False):
''' Finds average of three best by give metric.'''
df = get_pickle(folder='tiingo', name='SPY')
market = df['SPY_AdjClose'].pct_change()
c = concat([market, data], axis=1)
c.columns = ['market', 'subject']
c['ret'] = c['subject'].pct_change()
res = []
for i in r:
try:
c['func'] = c['subject'].rolling(window=i, min_periods=i).mean()
c['action'] = where(op(c['subject'].shift(), c['func'].shift()),
c['ret'], 0)
c = c.dropna()
r = stats_values(returns=c['action'], market=c['market'])[factor]
res.append([i, r])
except Exception as err:
pass
if len(res) > 0:
res = sorted(res, key=lambda x: x[1], reverse=rev)
res = [r[0] for r in res][:3]
return sum(res) / 3.0
def run_analyze(model):
try:
model = int(model)
except:
model = None
pass
'''
BASKET = ['BSX', 'AIG', 'INTU', 'INTC', 'HON', 'DUK', 'NTAP', 'COL', 'ABT', 'ADSK', 'NUE',
'MU', 'TIF', 'ADBE', 'FDX', 'NKE', 'TAP', 'SCHW', 'STI', 'CIT', 'LNC', 'MAT', 'ARNC',
'ADI', 'AFL', 'KEY', 'HD', 'OKE', 'LOW', 'RF', 'OI', 'AES', 'LUV', 'TXT', 'UNH', 'DVN',
'CCL', 'MRO', 'EOG', 'T', 'AVY', 'CI', 'BK', 'CSR', 'AAPL', 'ZBH', 'CTXS', 'ALL', 'SHW',
'COF', 'SNA', 'AET', 'SYY', 'UNM', 'GTE', 'GWW', 'BVSN', 'BLL', 'COST', 'CS', 'HPQ',
'CTAS', 'AMAT', 'WFC', 'EFU', 'HRB', 'ADM', 'NWL', 'EFX', 'PGR', 'BBT', 'NVDA', 'ARC',
'SGI', 'JPM', 'GIS', 'PHM', 'PCAR', 'PKI', 'NOC', 'SUB', 'APD', 'ITW', 'OXY', 'FMC',
'BDX', 'AXP', 'SLB', 'TX', 'TWX', 'AGN', 'ZION', 'CMA', 'A', 'TKR', 'FISV', 'CCK',
'AEE', 'APA', 'TJX', 'CSCO', 'GRA', 'AMGN', 'DOV', 'WMT', 'EQR', 'LMT', 'BAC', 'NC',
'PH', 'VMC', 'VO', 'EMR', 'HAS', 'ECL', 'CINF', 'C', 'DNB', 'AGC', 'BGG', 'TMK', 'SWK',
'BFO', 'APC', 'LLY', 'NEM', 'NEE', 'VZ', 'PBY', 'SMI', 'PNC', 'MSFT', 'H', 'CMS',
'BAX', 'ADP', 'CAH', 'SYK', 'EMN', 'PCH', 'ABC', 'KSU', 'IFF', 'CA', 'CLX', 'TGT',
'JNJ', 'SRV', 'AON', 'VFC', 'MMC', 'FLR', 'ORCL', 'BBY', 'CBS', 'MAS', 'CAG', 'RAD',
'GPC', 'HES', 'RHI', 'AZO', 'CNP', 'CTL', 'XLNX', 'MCD', 'LB', 'CSX', 'YUM', 'USB',
'GPS', 'PX', 'CHA', 'MDT', 'WMB', 'JWN', 'CMI', 'IPG', 'DIS']
'''
BASKET = ['QQQ', 'SPY', 'IWM', 'EEM', 'TLT']
initial = get_pickle(DATA_SOURCE, BASKET[0])
initial = transform_multi_data(data=initial, symbol=BASKET[0])
data = join_data(primary=initial, folder=DATA_SOURCE, symbols=BASKET[1:])
data = clean_prices(data=data, symbols=BASKET, d_type='eod')
if model is None:
for i in all_alphas():
print('Alpha %s' % i)
run_factor(data, i, BASKET)
else:
run_factor(data, model, BASKET)
def stats_values(returns):
market = get_pickle('tiingo', 'SPY')['SPY_AdjClose'].pct_change()
df = concat([returns, market], axis=1)
df.columns = ['returns', 'market']
df = df.dropna()
returns = df['returns']
market = df['market']
c = returns.cumsum()
vv = vol(returns=returns) * 100.0
amr = average_month_return(returns=returns)
# trade_count(signals)
at = average_trade(returns=returns) * 100.0
aw = average_win(returns=returns) * 100.0
al = average_loss(returns=returns) * 100.0
w = total_wins(returns=returns)
l = total_losses(returns=returns)
pf = profit_factor(returns=returns)
wr = win_rate(returns=returns) * 100.0
acor = correlation(returns=returns)
sr = sharpe_ratio(returns, rf=0.0)
b = beta(returns=returns, benchmark=market)
a = alpha(returns=returns, rf=0.0, market_return=market)
tr = treynor(returns=returns, benchmark=market, rf=0.0)
infr = ir(returns=returns, benchmark=market)
mod = modigliani(returns=returns, benchmark=market, rf=0.0)
ora = omega_ratio(returns=returns, rf=0.0, target=0.0)
so = sortino(returns=returns, rf=0.0, target=0)
kt = kappa_three(returns=returns, rf=0.0, target=0.05)
up = upside_potential(returns=returns, target=0.0)
cal = calmar(returns=returns, rf=0.0)
ui = ulcer_index(cumulative=c)
upi = ulcer_performance_index(cumulative=c, r=returns.mean(), rf=0.0)
stra = sterling_ration(returns=returns, rf=0.0)
br = burke_ratio(returns=returns, cumulative=c, rf=0.0)
v = var(returns=returns, alpha=a)
cvv = cvar(returns=returns, alpha=a)
ev = excess_var(returns=returns, rf=0.0, alpha=a)
cs = conditional_sharpe(returns=returns, rf=0.0, alpha=a)
mdd = max_dd(returns=returns) * 100.0
add = average_dd(cumulative=c) * 100.0
adds = average_dd_squared(cumulative=c) * 100.0
mdddur = max_dd_duration(cumulative=c)
dp = drawdown_probability(cumulative=c)
rp = return_probability(returns=returns)
cs = common_sense(returns=returns)
wlr = win_loss_ratio(returns=returns)
cpc = cpc_index(returns=returns)
tailr = tail_ratio(returns=returns)
owr = outlier_win_ratio(returns=returns)
olr = outlier_loss_ratio(returns=returns)
start = get_start(returns=returns)
end = get_end(returns=returns)
ys = get_years_count(returns=returns)
tret = total_return(returns=returns)
cgr = cagr(returns=returns)
_ytd = ytd(returns=returns)
_mtd = mtd(returns=returns)
three_month = mos(returns=returns, m=3)
six_month = mos(returns=returns, m=6)
three_year = mos(returns=returns, m=36)
dailyskew = daily_skew(returns=returns)
daily_kurt = daily_kurtosis(returns=returns)
bestday = best_day(returns)
worstday = worst_day(returns)
monthlyvol = monthly_vol(returns=returns)
monthlyskew = monthly_skew(returns=returns)
monthlykurt = monthly_skew(returns=returns)
bestmonth = best_month(returns=returns)
worstmonth = worst_month(returns=returns)
bestyear = best_year(returns=returns)
worstyear = worst_year(returns=returns)
yearlymean = yearly_mean(returns=returns)
yearlyvol = yearly_vol(returns=returns)
yearlyskew = yearly_skew(returns=returns)
yearly_kurt = yearly_kurtosis(returns=returns)
avg_down_month = average_down_month(returns=returns)
avg_up_month = average_up_month(returns=returns)
win_year_perc = win_years_percent(returns=returns) * 100.0
win_mo_perc = win_months_percent(returns=returns) * 100.0
win_w_perc = win_weeks_percent(returns=returns) * 100.0
return {
'volatility': vv,
'average_month': amr,
'average_trade': at,
'average_win': aw,
'average_loss': al,
'total_wins': w,
'total_losses': l,
'win_rate': wr,
'autocorrelation': acor,
'sharpe': sr,
'beta': b,
'alpha': a,
'treynor': tr,
'information': infr,
'win_rate': wr,
'modigliani': mod,
'omega': ora,
'sortino': so,
'kappa': kt,
'upside': up,
'calmar': cal,
'ulcer_index': ui,
'ulcer_performance_index': upi,
'sterling': stra,
'burke': br,
'VaR': v,
'cVaR': cvv,
'eVaR': ev,
'conditional_sharpe': cs,
'max_dd': mdd,
'average_dd': add,
'average_dd_squared': adds,
'max_dd_duration': mdddur,
'dd_prob': up,
'return_prob': rp,
'profit_factor': pf,
'common_sense': cs,
'win_loss_ratio': wlr,
'cpc_index': cpc,
'tail_ratio': tailr,
'outlier_win_ratio': owr,
'outlier_loss_ratio': olr,
'start': start,
'end': end,
'years': ys,
'total_return': tret,
'cagr': cgr,
'ytd': _ytd,
'mtd': _mtd,
'three_month': three_month,
'six_month': six_month,
'three_year': three_year,
'daily_skew': dailyskew,
'daily_kurt': daily_kurt,
'best_day': bestday,
'worst_day': worstday,
'monthly_vol': monthlyvol,
'monthly_skew': monthlyskew,
'monthly_kurt': monthlykurt,
'best_month': bestmonth,
'worst_month': worstmonth,
'best_year': bestyear,
'worst_year': worstyear,
'yearly_mean': yearlymean,
'yearly_vol': yearlyvol,
'yearly_skew': yearlyskew,
'yearly_kurt': yearly_kurt,
'avg_down_month': avg_down_month,
'avg_up_month': avg_up_month,
'win_year_perc': win_year_perc,
'win_months_perc': win_mo_perc,
'win_weeks_perc': win_w_perc
}
def stats_printout(returns, tf=1440):
if tf == 1440:
market = get_pickle('tiingo', 'SPY')['SPY_AdjClose'].pct_change()
df = concat([returns, market], axis=1)
df.columns = ['returns', 'market']
df = df.dropna()
returns = df['returns']
market = df['market']
c = returns.cumsum()
print('Basics -----------------------')
start = get_start(returns=returns)
print('Start: %s' % start)
end = get_end(returns=returns)
print('End: %s' % end)
ys = get_years_count(returns=returns)
print('Years: %.0f' % ys)
tret = total_return(returns=returns)
print('Total return: %.2f%%' % tret)
# @TODO initial valeus should be already reinvested
cgr = cagr(returns=returns)
print('CAGR: %.2f%%' % cgr)
_ytd = ytd(returns=returns)
print('YTD: %.2f%%' % _ytd)
_mtd = mtd(returns=returns)
print('Month to date: %.2f%%' % _mtd)
three_month = mos(returns=returns, m=3)
print('3 months: %.2f%%' % three_month)
six_month = mos(returns=returns, m=6)
print('6 months: %.2f%%' % six_month)
three_year = mos(returns=returns, m=36)
print('3 years: %.2f%%' % three_year)
dailyskew = daily_skew(returns=returns)
print('Daily skew: %.2f' % dailyskew)
daily_kurt = daily_kurtosis(returns=returns)
print('Daily kurtosis: %.2f' % daily_kurt)
bestday = best_day(returns)
print('Best day: %.2f%%' % bestday)
worstday = worst_day(returns)
print('Worst day: %.2f%%' % worstday)
monthlyvol = monthly_vol(returns=returns)
print('Monthly volatility: %.2f%%' % monthlyvol)
monthlyskew = monthly_skew(returns=returns)
print('Monthly skew: %.2f' % monthlyskew)
monthlykurt = monthly_skew(returns=returns)
print('Monthly kurtosis: %.2f' % monthlykurt)
bestmonth = best_month(returns=returns)
print('Best month: %.2f%%' % bestmonth)
worstmonth = worst_month(returns=returns)
print('Worst month: %.2f%%' % worstmonth)
bestyear = best_year(returns=returns)
print('Best year: %.2f%%' % bestyear)
worstyear = worst_year(returns=returns)
print('Worst year: %.2f%%' % worstyear)
yearlymean = yearly_mean(returns=returns)
print('Yearly average: %.2f%%' % yearlymean)
yearlyvol = yearly_vol(returns=returns)
print('Yearly volatility: %.2f%%' % yearlyvol)
yearlyskew = yearly_skew(returns=returns)
print('Yearly skew: %.2f' % yearlyskew)
yearly_kurt = yearly_kurtosis(returns=returns)
print('Yearly kurtosis: %.2f' % yearly_kurt)
avg_down_month = average_down_month(returns=returns)
print('Average down month %.2f%%' % avg_down_month)
avg_up_month = average_up_month(returns=returns)
print('Average up month: %.2f%%' % avg_up_month)
win_year_perc = win_years_percent(returns=returns) * 100.0
print('Win years: %.2f%%' % win_year_perc)
win_mo_perc = win_months_percent(returns=returns) * 100.0
print('Win months: %.2f%%' % win_mo_perc)
win_w_perc = win_weeks_percent(returns=returns) * 100.0
print('Win weeks: %.2f%%' % win_w_perc)
vv = vol(returns=returns)
print('Volatility %.3f%%' % (vv * 100.0))
amr = average_month_return(returns=returns)
print('Average month return %.3f%%' % amr)
pf = profit_factor(returns=returns)
print('Profit factor %.2f' % pf)
at = average_trade(returns=returns) * 100.0
print('Average trade %.2f%%' % at)
aw = average_win(returns=returns) * 100.0
print('Average win %.2f%%' % aw)
al = average_loss(returns=returns) * 100.0
print('Average loss %.2f%%' % al)
w = total_wins(returns=returns)
print('Wins %s' % w)
l = total_losses(returns=returns)
print('Losses %s' % l)
wr = win_rate(returns=returns) * 100.0
print('Win rate %.3f%%' % wr)
acor = correlation(returns=returns)
print('Autocorrelation %.3f' % acor)
print()
print('Ratios -----------------------')
print('Sharpe* %.3f' % (sharpe_ratio(returns, rf=0.0)))
monthlysharpe = monthly_sharpe(returns=returns)
print('Monthly Sharpe: %.2f' % monthlysharpe)
weeklysharpe = weekly_sharpe(returns=returns)
print('Weekly Sharpe: %.2f' % weeklysharpe)
yearlysharpe = yearly_sharpe(returns=returns)
print('yearly Sharpe: %.2f' % yearlysharpe)
cs = common_sense(returns=returns)
print('Common Sense Ratio: %.2f' % cs)
if tf == 1440:
b = beta(returns=returns, benchmark=market)
print('Beta %.3f' % b)
a = alpha(returns=returns, rf=0.0, market_return=market)
print('Alpha %.3f' % a)
tr = treynor(returns=returns, benchmark=market, rf=0.0)
print('Treynor* %.3f' % tr)
infr = ir(returns=returns, benchmark=market)
print('Information ratio %.3f' % infr)
mod = modigliani(returns=returns, benchmark=market, rf=0.0)
print('Modigliani ratio* %.3f' % mod)
ora = omega_ratio(returns=returns, rf=0.0, target=0.0)
print('Omega Ratio* %.3f' % ora)
so = sortino(returns=returns, rf=0.0, target=0)
print('Sortino Ratio* %.3f' % so)
kt = kappa_three(returns=returns, rf=0.0, target=0.05)
print('Kappa Three %.3f' % kt)
up = upside_potential(returns=returns, target=0.0)
print('Upside potential ratio %.3f' % up)
cal = calmar(returns=returns, rf=0.0)
print('Calmar Ratio* %.3f' % cal)
ui = ulcer_index(cumulative=c)
print('Ulcer Index %.3f' % ui)
upi = ulcer_performance_index(cumulative=c, r=returns.mean(), rf=0.0)
print('Ulcer Performance Index* %.3f' % upi)
stra = sterling_ration(returns=returns, rf=0.0)
if stra is not None:
print('Sterling Ratio* %.3f' % stra)
br = burke_ratio(returns=returns, cumulative=c, rf=0.0)
print('Burke Ratio* %.3f' % br)
wlr = win_loss_ratio(returns=returns)
print('Win-Loss Ratio %.2f' % wlr)
cpc = cpc_index(returns=returns)
print('CPC Index %.3f' % cpc)
tailr = tail_ratio(returns=returns)
print('Tail ratio %.3f' % tailr)
owr = outlier_win_ratio(returns=returns)
print('Outlier win ratio %.3f' % owr)
olr = outlier_loss_ratio(returns=returns)
print('Outlier loss ratio %.3f' % olr)
if tf == 1440:
print()
print('VaR --------------------------')
v = var(returns=returns, alpha=a)
print('VaR %.3f' % v)
cvv = cvar(returns=returns, alpha=a)
print('Conditional VaR %.3f' % cvv)
ev = excess_var(returns=returns, rf=0.0, alpha=a)
print('Excess VaR* %.3f' % ev)
cs = conditional_sharpe(returns=returns, rf=0.0, alpha=a)
print('Conditional Sharpe* %.3f' % (cs * sqrt(252)))
print()
print('DD ---------------------------')
mdd = max_dd(returns=returns) * 100.0
print('Max DD %.3f%%' % mdd)
add = average_dd(cumulative=c) * 100.0
print('Average DD %.2f%%' % add)
adds = average_dd_squared(cumulative=c) * 100.0
print('Average DD Squared %.3f%%' % adds)
mdddur = max_dd_duration(cumulative=c)
print('Max DD duration %s' % mdddur)
dp = drawdown_probability(cumulative=c)
print('Drawdown probability %.3f' % dp)
rp = return_probability(returns=returns)
print('Return probability %.3f' % rp)
print('* Values are annualized.')
def get_tfs(e):
try:
return [s[0] for s in get_pickle(join('ccxt', 'tfs'), e[0], as_is=True).values]
except FileNotFoundError:
pass
