def __init__(self,
folio_ts,
peer,
user_id=None,
factors=None,
Index=0,
regime_model=None):
if user_id:
peer_folio_ts = peer.folio_ts
else:
peer_folio_ts = peer.Performance
common_data = align_series([folio_ts, peer_folio_ts])
self.Name = peer.Name
self.entire_return = peer.entire_history if user_id else 0
self.HashKey = peer.folio_id if user_id else peer.coin_id
self.corr = common_data.corr().iloc[0, 1]
self.peer_stats = BasicStats(peer_folio_ts)
self.coin_stats = BasicStats(folio_ts)
self.peer_ts = peer_folio_ts
self.folio_ts = folio_ts
self.index = Index
if factors:
self.factors = factors
self.factor_ts = [f.Performance for f in self.factors]
self.peer_style = RegressionAnalysis(self.peer_ts, self.factor_ts)
else:
self.coin_style = None
self.peer_style = None
if regime_model:
self.regime_stats = RegimeAnalysis(peer, regime_model, peer,
user_id)
self.XY = common_data.values
async def analysis(self):
if not self.bench_ticker:
self.benchmark_ticker = "^bitcoin"
else:
self.benchmark_ticker = self.bench_ticker
self.benchmark = await self.db.get_risk_factor(self.benchmark_ticker,
self.modify_at)
if self.item:
performance_data = self.item.folio_ts
else:
performance_data = Series()
self.item_ts = performance_data
self.bench_ts = self.benchmark.Performance if self.benchmark else Series(
)
self.reg_capm = RegressionAnalysis(self.item_ts, self.bench_ts)
self.bench_ts2 = self.bench_ts**2
self.bench_ts2.name = 'TMY'
self.reg_tmy = RegressionAnalysis(self.item_ts,
[self.bench_ts, self.bench_ts2])
self.corr_analysis = CorrelationAnalysis(self.item_ts, self.bench_ts)
self.captures = CaptureRatios(self.item_ts, self.bench_ts)
self.coin_stats = BasicStats(self.item_ts)
self.bench_stats = BasicStats(self.bench_ts)
def calculate_stats(self):
self.basicStats = BasicStats(self.perf)
n = len(self.data_frame.columns)
self.n_benchmarks = n - 1
self.mddser = self.basicStats.mdd_ser
self.mdd_dates = self.mddser.index
self.mdds = self.mddser.values
styleTime = (datetime.utcfromtimestamp(int(
self.start_at))) if self.start_at else ""
def day_date(date_str):
if len(str(date_str)) == 1:
return "0%s" % str(date_str)
else:
return str(date_str)
def compare_date(d):
return (
int(str(d.year) + day_date(d.month) + day_date(d.day)) >= int(
str(styleTime.year) + day_date(styleTime.month) +
day_date(styleTime.day))) if styleTime else False
if n > 1:
bench_values = self.data_frame[self.data_frame.columns[1]].values
bench_series = Series(data=bench_values,
index=self.data_frame.index)
self.bench_stats = BasicStats(bench_series)
self.bench_mdd = self.bench_stats.mdd_ser
self.mdd_res = sorted([
(d, m, b)
for d, m, b in zip(self.mdd_dates, self.mdds, self.bench_mdd)
])
self.mdd_reses = [[{
"year": str(d.year),
"month": day_date(d.month),
"day": day_date(d.day)
}, m, b,
compare_date(d)] for d, m, b in self.mdd_res]
else:
self.mdd_res = sorted([(d, m)
for d, m in zip(self.mdd_dates, self.mdds)])
self.mdd_reses = [[{
"year": str(d.year),
"month": day_date(d.month),
"day": day_date(d.day)
},
toDecimal(m),
compare_date(d)] for d, m in self.mdd_res]
self.var = toDecimal(self.basicStats.var)
def calculate_fts(fts=[], dates=[]):
if fts:
pre_fts = [100]
new_fts = []
pre_val = 100
for index, ft in enumerate(fts[1:]):
pre_fts.append(pre_val * (ft + 1))
pre_val = pre_val * (ft + 1)
pre_fts.reverse()
for index, ft in enumerate(pre_fts):
if index < len(pre_fts) - 1:
val = float(
round(
float((ft - pre_fts[index + 1]) / pre_fts[index + 1]),
5))
new_fts.append(val)
else:
new_fts.append(0.0)
new_fts.reverse()
fts = new_fts
week_ser_fts = Series(data=fts[-7:], index=dates[-7:], name="")
week_mdd_ser = BasicStats.under_water_series(week_ser_fts)
week_max_drawdown = min(week_mdd_ser)
vami = BasicStats.vami_arr(week_ser_fts)
day_7_history = vami[-1] - 1
ser_fts = Series(data=fts, index=dates, name="")
mdd_ser = BasicStats.under_water_series(ser_fts)
total_max_drawdown = min(mdd_ser)
vami = BasicStats.vami_arr(ser_fts)
entire_history = vami[-1] - 1
week_fts = fts[-7:]
week_volatility = np.std(week_fts)
total_volatility = np.std(fts)
return {
"week_volatility": "%s%%" % str(round(week_volatility * 100, 3)),
"week_max_drawdown": "%s%%" % str(round(week_max_drawdown, 3)),
"total_volatility": "%s%%" % str(round(total_volatility * 100, 3)),
"total_max_drawdown": "%s%%" % str(round(total_max_drawdown, 3)),
"entire_history": float(round(entire_history * 100, 4)),
"day_7_history": float(round(day_7_history * 100, 4))
}
else:
return {}
self.help_dict[field_name] = field
def help(self, obj):
obj_dict = obj.__dict__
fields = [self.help_dict[f] for f in self.field_list if f in obj_dict]
return [[
f.label,
f.format(obj_dict[f.key]) if float(obj_dict[f.key]) *
100 < 1000 else ">1000%"
] if f.key == "ann_return" else [f.label,
f.format(obj_dict[f.key])]
for f in fields]
def init_help(self):
fields = [self.help_dict[f] for f in self.field_list]
return [[f.label, "0"] for f in fields]
if __name__ == '__main__':
helper = StatsHelper()
from analytics.basicstats import BasicStats
from datalib.datalib import Connection
coinid = 'e042001c-9a43-11e6-bfb2-14109fdf0df7'
db = Connection.getInstance()
coin = db.get_coin(coinid)
stats = BasicStats(coin.Performance)
res = helper.help(stats)
async def portfolio_ratios(port_folio=None, folio_id="", db=None, lang="en"):
try:
if not db:
db = Connection.getInstance()
if not port_folio:
if folio_id:
port_folio = await folios_dao.findFolio(folio_id)
if not port_folio:
return None
else:
return None
helper = StatsHelper(lang=lang)
proforma = await folios_dao.GetFolioPerformance(port_folio.id)
if proforma:
fts = proforma["pre_data"]["data"]
now_data = [nowData["data"] for nowData in proforma["now_data"]]
now_fts = []
for d in now_data:
fts.extend(d)
now_fts.extend(d)
prof_fts = [perf["NetReturn"] for perf in now_fts]
dates = [
datetime.fromtimestamp(p['EffectiveDate']) for p in now_fts
]
fts_data = calculate_fts(prof_fts, dates)
dates = [datetime.fromtimestamp(p['EffectiveDate']) for p in fts]
prof_array = [perf["NetReturn"] for perf in fts]
fts = Series(data=prof_array, index=dates, name=port_folio.name)
T = len(fts)
referenceData = await report_dao.findReferenceData('Risk Free Rate'
)
if referenceData:
rf = float(referenceData.data) * 0.01
else:
rf = 0
stats_all = BasicStats(fts,
risk_free=rf,
folio_name=port_folio.name)
roll_windows = windows[stats_all.freq[0]]
roll_results = []
ratio_items = {
"Cumulative Return": [],
"Period volatility": {
"volatility": "",
"day_7_volatility": ""
},
"Max Drawdown": {
"max_drawdown": "",
"day_7_drawdown": ""
},
"entire_history": "",
"day_7_history": ""
}
resultsAll = helper.help(stats_all)
result_dict = dict(resultsAll)
ratio_items["entire_history"] = fts_data[
"entire_history"] if fts_data else 0.0
ratio_items["day_7_history"] = fts_data[
"day_7_history"] if fts_data else 0.0
ratio_items["Period volatility"]["volatility"] = fts_data[
"total_volatility"] if fts_data else 0.0
ratio_items["Max Drawdown"]["max_drawdown"] = fts_data[
"total_max_drawdown"] if fts_data else 0.0
ratio_items["Cumulative Return"].append(
result_dict.get(_("Cumulative Return", lang), ""))
for index, w in enumerate(roll_windows):
if T >= w:
roll_fts = fts[-1 * w:]
ratio_data = helper.help(BasicStats(roll_fts,
risk_free=rf))
ratio_dict = dict(ratio_data)
val = ratio_dict.get(_("Cumulative Return", lang), "")
ratio_items["Cumulative Return"].append(val)
if index == 0:
ratio_items["Max Drawdown"][
"day_7_drawdown"] = fts_data[
"week_max_drawdown"] if fts_data else 0.0
ratio_items["Period volatility"][
"day_7_volatility"] = fts_data[
"week_volatility"] if fts_data else 0.0
roll_results.append([w, ratio_data])
await folios_dao.updateFolioHistory(port_folio.id, ratio_items)
reportData = {
"ResultsAll": resultsAll,
"RollResults": roll_results,
"Coin": {
"Name": port_folio.name
}
}
params = "ratios_%s" % lang
await db.set_cache(port_folio.id,
"portfolio",
params,
data=reportData,
modify_at=port_folio.modify_at)
else:
roll_results = []
ratio_items = {
"Cumulative Return": [],
"Period volatility": {
"volatility": ""
},
"Max Drawdown": {
"max_drawdown": "",
"day_7_drawdown": ""
}
}
resultsAll = helper.init_help()
result_dict = dict(resultsAll)
ratio_items["Period volatility"]["volatility"] = result_dict.get(
"% Volatility", "")
ratio_items["Max Drawdown"]["max_drawdown"] = result_dict.get(
"Max Drawdown", "")
ratio_items["Cumulative Return"].append(
result_dict.get("Cumulative Return", ""))
await folios_dao.updateFolioHistory(port_folio.id, ratio_items)
reportData = {
"ResultsAll": resultsAll,
"RollResults": roll_results,
"Coin": {
"Name": port_folio.name
}
}
except Exception as e:
errMsg = getErrorMsg()
error("portfolio_ratios exception is: %s, errMsg: %s" %
(str(e), str(errMsg)))
reportData = {}
return reportData