async def findAll(cls, where=None, args=None, **kw):
' find objects by where clause. '
try:
sql = [cls.__select__]
if where:
sql.append('where')
sql.append(where)
if args is None:
args = []
orderBy = kw.get('orderBy', None)
if orderBy:
sql.append('order by')
sql.append(orderBy)
limit = kw.get('limit', None)
if limit is not None:
sql.append('limit')
if isinstance(limit, int):
sql.append('?')
args.append(limit)
elif isinstance(limit, tuple) and len(limit) == 2:
sql.append('?, ?')
args.extend(limit)
else:
raise ValueError('Invalid limit value: %s' % str(limit))
rs = await select(' '.join(sql), args)
return [cls(**r) for r in rs]
except Exception as e:
errMsg = getErrorMsg()
error(
"orm findAll error is: %s, kw is %s, where is %s, args is %s" %
(str(errMsg), str(kw), str(where), str(args)))
return []
def wrapper(*args, **kw):
try:
return func(*args, **kw)
except Exception as e:
errMsg = getErrorMsg()
error("options api error is: %s"%str(errMsg))
result = {"error": 500, "data": "", "message": _("500_SERVER_ERROR", kw.get("language","en"))}
return result
async def remove(self):
try:
args = [self.getValue(self.__primary_key__)]
rows = await execute(self.__delete__, args)
if rows != 1:
error('failed to remove by primary key: affected rows: %s, args : %s' % (rows, str(args)))
return rows
except Exception as e:
errMsg = getErrorMsg()
error("orm remove error is: %s" % (errMsg))
return None
async def find(cls, pk):
'find object by primary key'
try:
rs = await select('%s where `%s`= ?' % (cls.__select__, cls.__primary_key__), [pk], 1)
if len(rs) == 0:
return None
return cls(**rs[0])
except Exception as e:
errMsg = getErrorMsg()
error("orm find error is: %s, pk is %s" % (str(errMsg),str(pk)))
return None
async def update(self):
try:
args = list(map(self.getValue, self.__fields__))
args.append(self.getValue(self.__primary_key__))
rows = await execute(self.__update__, args)
if rows != 1:
error('failed to update by primary key: affected rows: %s, args : %s' % (rows, str(args)))
return rows
except Exception as e:
errMsg = getErrorMsg()
error("orm update error is: %s" % (errMsg))
return None
async def save(self):
try:
args = list(map(self.getValueOrDefault, self.__fields__))
args.append(self.getValueOrDefault(self.__primary_key__))
rows = await execute(self.__insert__, args)
if rows != 1:
error('failed to insert record: affected rows :%s, args : %s' % (rows, str(args)))
return rows
except Exception as e:
errMsg = getErrorMsg()
error("orm save error is: %s" % (errMsg))
return None
async def execute(sql, args):
global __pool
with (await __pool) as conn:
try:
cur = await conn.cursor()
await cur.execute(sql.replace('?', '%s'), args or ())
affected = cur.rowcount
await cur.close()
except BaseException as e:
error("execute Exception is -------------------> : %s, sql is %s, args is %s"%(str(e), str(sql), str(args)))
raise
return affected
async def token2user(token):
if not token:
return None
try:
redis_obj = Redis.getInstance()
user = redis_obj.get(token)
if user is None:
return None
user = json.loads(
user.decode()) if not isinstance(user, dict) else user
redis_obj.set_expire(token, 3600 * 24)
return user
except Exception as e:
error("token2user exception is: %s" % str(e))
return None
async def findNumber(cls, selectField, where=None, args=None):
' find number by select and where. '
try:
sql = ['select %s _num_ from `%s`' % (selectField, cls.__table__)]
if where:
sql.append('where')
sql.append(where)
rs = await select(' '.join(sql), args, 1)
if len(rs) == 0:
return None
return rs[0]['_num_']
except Exception as e:
errMsg = getErrorMsg()
error(
"orm findNumber error is: %s, selectField is %s, where is %s, args is %s"
% (str(errMsg), str(selectField), str(where), str(args)))
return None
async def frequency(remote_ip, path_url):
try:
fast_rep = 0
redis_obj = Redis.getInstance()
data_val = redis_obj.getHash(remote_ip, path_url)
try:
data_val = json.loads(data_val.decode())
val = data_val.get("now_time", "") if isinstance(
data_val, dict) else data_val
num = data_val.get("num", "") if isinstance(data_val, dict) else 1
now_time = int(time.time() * 1000)
pre_time = data_val.get("pre_time", "") if isinstance(
data_val, dict) else now_time
except:
now_time = int(time.time() * 1000)
pre_time = now_time
val = ""
num = 1
request_info("frequency val:%s" % str(val))
if not val:
data = {"now_time": now_time, "num": 1, "pre_time": now_time}
redis_obj.setHash(remote_ip, path_url, json.dumps(data))
redis_obj.setHashExpire(remote_ip, 3600)
else:
if now_time - int(val) < 200:
fast_rep = 1
if num >= 60 and now_time - pre_time <= 60000:
fast_rep = 1
num += 1
elif now_time - pre_time > 60000:
pre_time = now_time
num = 1
else:
num += 1
data = {"now_time": now_time, "num": num, "pre_time": pre_time}
redis_obj.setHash(remote_ip, path_url, json.dumps(data))
redis_obj.setHashExpire(remote_ip, 3600)
return fast_rep
except Exception as e:
error("frequency exception is: %s" % str(e))
return None
def __call__(self, request):
kw = None
if self._has_var_kw_arg or self._has_named_kw_arg or self._required_kw_args or self._named_kw_args:
if request.method in ('POST',"OPTIONS"):
if not request.content_type:
r = {"error": 404, "data": {}, "message": 'Missing Content-Type'}
resp = to_response(r, method=request.method)
return resp
ct = request.content_type.lower()
if ct.startswith('application/json'):
params = yield from request.json()
if not isinstance(params, dict):
r = {"error": 404, "data": {}, "message": 'JSON Body must be object'}
resp = to_response(r, method=request.method)
return resp
kw = params
elif ct.startswith('application/x-www-form-urlencoded') or ct.startswith('multipart/form-data'):
params = yield from request.post()
kw = dict(**params)
else:
r = {"error": 404, "data": {}, "message": 'Unsupported Content-Type:%s' % request.content_type}
resp = to_response(r, method=request.method)
return resp
if request.method == 'GET':
qs = request.query_string
if qs:
kw = dict()
for k, v in parse.parse_qs(qs, True).items():
kw[k] = v[0]
if kw is None:
kw = dict(**request.match_info)
else:
if not self._has_var_kw_arg and self._named_kw_args:
copy = dict()
for name in self._named_kw_args:
if name in kw:
copy[name] = kw[name]
kw = copy
for k, v in request.match_info.items():
if k in kw:
error('Duplicate arg name in named arg and kw args: %s' % k)
kw[k] = v
if self._has_request_arg:
kw['request'] = request
language = toExistLanguage(kw.get("language", "en"))
if self._required_kw_args:
for name in self._required_kw_args:
if not name in kw:
r = {"error": 500, "data": {}, "message": _("500_SERVER_ERROR", language)}
resp = to_response(r, method=request.method)
return resp
request_info('call with args: %s' % str(kw))
try:
res = yield from self.request_frequency(request, kw)
if res == True:
resp = yield from self.getToken(request, kw)
if resp == True:
if "token" in kw:
del kw["token"]
if "language" in kw:
del kw["language"]
r = yield from self._func(**kw)
return r
else:
return resp
else:
return res
except Exception as e:
errMsg = getErrorMsg()
error("__call__ api error is: %s"%str(errMsg))
r = {"error": 500, "data": {}, "message": _("500_SERVER_ERROR", language)}
resp = to_response(r, method=request.method)
return resp
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
