def callback(ch, method, properties, body):
#print("[X] Received %r" % (body.decode('utf-8'),))
message = body.decode('utf-8')
#message = body.decode()
jsonobj = json.loads(message)
task_model_name = jsonobj["mn"]
task_service_name = jsonobj["sn"]
task_service_file = jsonobj["sf"]
indicatorId = ""
if ("indicator_id" in jsonobj):
indicatorId = jsonobj["indicator_id"]
print("准备执行service层%r的%r方法" % (task_service_file, task_service_name))
uuid = uuid_util.gen_uuid()
task_model_name = getattr(TaskModel, task_model_name)
service_class_name = importlib.import_module('fof.service.' +
task_service_file)
off_line_service = getattr(service_class_name, task_service_name)
if indicatorId == "":
model = OfflineTaskModel(task_model_name, off_line_service, "", uuid)
else:
model = OfflineTaskModel(task_model_name, off_line_service, "", uuid,
indicatorId, "1")
logic_processor.doLogic(model, )
print("消费完成")
ch.basic_ack(delivery_tag=method.delivery_tag)
def other_indicator(request):
"""
离线计算其他指标
:param request:
: indicatorId: 指标Id
:return:
"""
req = request.data
try:
bun = Bunch(req)
indicatorId = bun.indicatorId
except:
raise Error("indicatorId 不能为空")
uuid = uuid_util.gen_uuid()
model = OfflineTaskModel(TaskModel.qitazhibiao, offline_value_service.other_indicator, request, uuid,
extVal=indicatorId)
ThreadTool.pool.submit(logic_processor.doLogic, (model,))
view = OffLineView(uuid)
return JsonResponse(convert_to_dict(view))
def indicator_score_rank(request, format=None):
"""
指标打分
:param request:
indicatorId ： 指标id
{"indicatorId": "1"}
:return:
"""
req = request.data
logger.info("req:", req)
try:
m = Bunch(req)
indicatorId = m.indicatorId
except Exception as ae:
raise Error("参数验证异常", ae)
uuid = uuid_util.gen_uuid()
model = OfflineTaskModel(TaskModel.zhibiaodafen,
offline_score_service.indicator_score_rank,
request, uuid, indicatorId, "1")
ThreadTool.pool.submit(logic_processor.doLogic, (model, ))
view = OffLineView(uuid)
return JsonResponse(convert_to_dict(view))
def hand_turn_over(model):
# 能力分析 - 持股集中度、换手率
# fof_fund_stock_porfolio
if not del_data('fof_fund_stock_porfolio'):
raise Error("删除历史数据失败，任务结束")
fundSymbols = getData_fundSymbols(['股票型', '混合型'])
btParms = {
'symbol': fundSymbols,
'startDate': '20020101',
'endDate': datetime.strftime(datetime.today(), '%Y%m%d')
}
self = fundTurnOver(btParms)
output = self.output
for i in output:
val = output[i]
for k, v in val.items():
dt = k # 时间
value = v # 值
symbo = i # 基金
id_ = uuid_util.gen_uuid()
ls = []
ls.append(id_)
ls.append(symbo)
ls.append(dt._short_repr.replace("-", ""))
ls.append(transformFloatIfAvaliable3(value))
ls.append("sys")
ls.append(datetime.now())
ls.append("sys")
ls.append(datetime.now())
sql = "INSERT INTO `fof`.`fof_fund_stock_porfolio`(`OBJECT_ID`, `J_WINDCODE`, `TRADE_DT`, `CHANGE_RATE`, `CREATE_USER_ID`, `CREATE_TIME`, `UPDATE_USER_ID`, `UPDATE_TIME`) VALUES (%s, %s, %s, %s, %s, %s, %s, %s)"
mysqlops.insert_one(MysqlConf.DB.fof, sql, tuple(ls))
def compute_manager_product(model: OfflineTaskModel):
if not del_data('fof_manager_product'):
raise Error("删除历史数据失败，任务结束")
test = managerAnnualReturn()
mgrDF = test.output.fillna("999999999.9999")
# mgrDF.to_csv("C:\\Users\\futanghang\\Desktop\\nn.csv")
# mgrDF = pd.read_csv("C:\\Users\\futanghang\\Desktop\\mgr.csv")
for hls in mgrDF.values.tolist():
objId = uuid_util.gen_uuid()
ls = [transformFloatIfAvaliable3(l) for l in hls]
lst = []
lst.append(objId)
lst.append(ls[0])
lst.append(ls[1])
lst.append(ls[2])
lst.append(ls[5])
lst.append(ls[3])
lst.append(ls[4])
lst.append(ls[6][0:-2])
lst.append('sys')
lst.append(datetime.now())
lst.append("sys")
lst.append(datetime.now())
lst.append(0)
sql = "insert into fof_manager_product values (%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s)"
# fs = sql % tuple(lst)
mysqlops.insert_one(MysqlConf.DB.fof, sql, tuple(lst))
def callback(ch, method, properties, body):
# print("[X] Received %r" % (body.decode('utf-8'),))
message = body.decode('utf-8')
jsonobj = json.loads(message)
task_model_name = jsonobj["mn"]
task_service_name = jsonobj["sn"]
task_service_file = jsonobj["sf"]
indicatorId = ""
if ("indicator_id" in jsonobj):
indicatorId = jsonobj["indicator_id"]
print("准备执行service层%r" % task_service_name)
uuid = uuid_util.gen_uuid()
task_model_name = getattr(TaskModel, task_model_name)
service_class_name = __import__(task_service_file)
off_line_service = getattr(service_class_name, task_service_name)
if indicatorId == "":
model = OfflineTaskModel(task_model_name, off_line_service, "", uuid)
else:
model = OfflineTaskModel(task_model_name, off_line_service, "", uuid,
indicatorId, "1")
#启动长时间的任务线程执行
# worker = threading.Thread(target=thread_func, args=(ch, method, body,model))
logic_processor.doLogic(model)
# time1 = time.time()
# flag = True
# while flag:
# time2 = time.time()
# span = time2 - time1
# if span > 28800:
# flag = False
# print("退出任务")
ch.basic_ack(delivery_tag=method.delivery_tag)
def return_weight(model):
if not del_data('fof_fund_excess_return_weight'):
raise Error("删除历史数据失败，任务结束")
# fof_fund_excess_return_weight
# 一次性调取需要用到的公共数据
stockIndus, stockRet, indusRet, crIndus = publicData_stockAndIndustry()
# 批量生成基金经理任职区间信息
'''
首次存入数据库时需要全部运行，后续更新维护时只需更新在任基金经理信息即可.
选股能力仅针对于股票型与混合型基金
'''
managerInfo = getData_fundManagerInfo_all()
fundSymbols = getData_fundSymbols(['股票型', '混合型'])
tmp = []
for row in managerInfo.index:
if managerInfo.loc[row, 'fund'] in fundSymbols:
tmp.append(managerInfo.loc[row].to_dict())
managerInfo = pd.DataFrame(tmp, columns=managerInfo.columns)
output_all = []
for i in range(len(managerInfo)):
btParms = {
'symbol': managerInfo.loc[i, 'fund'],
'manager': managerInfo.loc[i, 'manager']
}
try:
test = stockPickingAbility_manager(btParms, stockIndus, stockRet,
indusRet, crIndus)
output = test.output
# output['compareReturnIndustry'].to_csv("c:\\users\\futanghang\\desktop\\compareReturnIndustry.csv")
# output['excessReturnIndustry'].to_csv("c:\\users\\futanghang\\desktop\\excessReturnIndustry.csv")
# output['excessReturnQuarter'].to_csv("c:\\users\\futanghang\\desktop\\excessReturnQuarter.csv")
# output['mainStcokReturn'].to_csv("c:\\users\\futanghang\\desktop\\mainStcokReturn.csv")
dda = output['excessReturnQuarter']
for k, v in dda.items():
# k time，v ：value
wCode = output['symbol'] # 基金Wind代码
managerName = output['manager'] # 基金经理名称
managerId = output['managerId'] # 基金经理id
id_ = uuid_util.gen_uuid() # objId
lst = []
lst.append(id_)
lst.append(wCode)
lst.append(managerId)
lst.append(managerName)
lst.append(k._short_repr.replace("-", ""))
lst.append(v)
lst.append("sys")
lst.append(datetime.now())
lst.append("sys")
lst.append(datetime.now())
ls = [transformFloatIfAvaliable4(i) for i in lst]
sql = "INSERT INTO `fof`.`fof_fund_excess_return_weight`(`OBJECT_ID`, `J_WINDCODE`, `MANAGER_ID`, `MANAGER_NAME`, `TRADE_DT`, `EXCESS_RETURN`, `CREATE_USER_ID`, `CREATE_TIME`, `UPDATE_USER_ID`, `UPDATE_TIME`) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s)"
mysqlops.insert_one(MysqlConf.DB.fof, sql, tuple(ls))
except Exception as e:
pass
def risk_multiple(model):
# 风险因子业绩归因模块
# fof_multi_attr_riskmodel
if not del_data('fof_multi_attr_riskmodel'):
raise Error("删除历史数据失败，任务结束")
stockIndus, indusReturn, factorExposure, factorReturn = publicData_riskModel(
)
# 批量运行
'''
跨期归因结果需要存储多个周期值
单期归因结果仅存储成立以来的值即可
跨期归因和单期归因可以用两张表来存储数据
'''
# dataframe 周期类型和数据库周期类型映射关系
cyleFormula = {'1': '1', '2': '2', '3': '3', '5': '4', '成立以来': '5'}
fundSymbols = getData_fundSymbols(['股票型', '混合型'])
cycleList = ['1', '2', '3', '5', '成立以来']
holdingTypeList = ['mainStockHolding', 'allStockHolding']
for holdingType in holdingTypeList:
for symbol in fundSymbols:
for cycle in cycleList:
btParms = {
'symbol': symbol,
'cycle': cycle,
'holdingType': holdingType
}
self = attribution_riskModel(btParms, stockIndus, indusReturn,
factorExposure, factorReturn)
output = self.output
tp = "1" if holdingType == 'mainStockHolding' else '2' # 持仓类型
param = output['multiAttr']
if len(param) == 0:
continue
for idx in param.index:
di = param.loc[idx].to_dict()
indexName = idx # 因子名称
indexType = di['factorType'] # 因子分类
indexAttr = di['multiAttr'] # 因子贡献收益
cyleTp = cyleFormula[cycle] # 周期类型
lsd = []
id_ = uuid_util.gen_uuid()
lsd.append(id_)
lsd.append(output['symbol'])
lsd.append(tp)
lsd.append(cyleTp)
lsd.append(indexType)
lsd.append(indexName)
lsd.append(indexAttr)
lsd.append("sys")
lsd.append(datetime.now())
lsd.append("sys")
lsd.append(datetime.now())
lsd = [transformFloatIfAvaliable4(l) for l in lsd]
sql = 'INSERT INTO `fof`.`fof_multi_attr_riskmodel`(`OBJECT_ID`, `S_INFO_WINDCODE`, `DATA_TYPE`, `CYCLE_TYPE`, `FACTOR_TYPE`, `FACTOR_NAME`, `FACTOR_VALUE`, `CREATE_USER_ID`, `CREATE_TIME`, `UPDATE_USER_ID`, `UPDATE_TIME`) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)'
mysqlops.insert_one(MysqlConf.DB.fof, sql, tuple(lsd))
def risk_single(model):
# 风险因子业绩归因模块
# fof_single_attr_riskmodel
if not del_data('fof_single_attr_riskmodel'):
raise Error("删除历史数据失败，任务结束")
stockIndus, indusReturn, factorExposure, factorReturn = publicData_riskModel(
)
# 批量运行
'''
跨期归因结果需要存储多个周期值
单期归因结果仅存储成立以来的值即可
跨期归因和单期归因可以用两张表来存储数据
'''
fundSymbols = getData_fundSymbols(['股票型', '混合型'])
cycleList = ['成立以来'] # 这个程序跟之前的程序有一点特殊，就是多期归因要存多个周期的结果，单期归因只存成立以来的结果
holdingTypeList = ['mainStockHolding', 'allStockHolding']
for holdingType in holdingTypeList:
for symbol in fundSymbols:
for cycle in cycleList:
btParms = {
'symbol': symbol,
'cycle': cycle,
'holdingType': holdingType
}
self = attribution_riskModel(btParms, stockIndus, indusReturn,
factorExposure, factorReturn)
output = self.output
tp = "1" if holdingType == 'mainStockHolding' else '2' # 持仓类型
param = output['singleAttr']
if len(param) == 0:
continue
for idx in param.index:
dt = idx # time
di = param.loc[idx].to_dict()
style = di['style'] # 风格因子归因
industry = di['industry'] # 行业因子归因
idiosyn = di['idiosyn'] # 特质因子归因
fundRet = di['fundRet'] # 基金当月收益率
lsd = []
id_ = uuid_util.gen_uuid()
lsd.append(id_)
lsd.append(output['symbol'])
lsd.append(dt._short_repr.replace("-", ""))
lsd.append(tp)
lsd.append(style)
lsd.append(industry)
lsd.append(idiosyn)
lsd.append(fundRet)
lsd.append("sys")
lsd.append(datetime.now())
lsd.append("sys")
lsd.append(datetime.now())
lsd = [transformFloatIfAvaliable4(l) for l in lsd]
sql = 'INSERT INTO `fof`.`fof_single_attr_riskmodel`(`OBJECT_ID`, `S_INFO_WINDCODE`, `TRADE_DT`, `DATA_TYPE`, `STYLE`, `INDUSTRY`, `IDIOSYN`, `FUND_RETURN`, `CREATE_USER_ID`, `CREATE_TIME`, `UPDATE_USER_ID`, `UPDATE_TIME`) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)'
mysqlops.insert_one(MysqlConf.DB.fof, sql, tuple(lsd))
def other_indicator(model: OfflineTaskModel):
# 离线计算其他指标
indicatorInfo = model.taskModel
indicatorId = model.extVal
if del_data(sqlPa="delete from fof_index_value where INDICATOR_ID = '%s'" % indicatorId) == False:
raise Error("删除历史数据失败，任务结束")
if indicatorId not in INDEX_CODE_NAME_CACHE.keys():
raise Error("指标id不存在:{}".format(indicatorId))
indexName = INDEX_CODE_NAME_CACHE[indicatorId]
# fundAdjNav = getPublicData(['股票型', '混合型'])
fundAdjNav = getPublicData()
fundSymbols = list(fundAdjNav.columns)
updatedType = []
fundClass_1 = pd.Series('混合型基金', index=fundSymbols)
fundClass_tmp = getData_fundInformation(fundSymbols)['FUND_INVESTTYPE']
fundClass_1[fundClass_tmp.index] = fundClass_tmp
for symbol in fundSymbols:
allIndicators = []
fundType = fundClass_1[symbol]
if fundType not in updatedType:
for cycle in n_cycle_tp:
btParms = {'indexName': indexName, 'cycle': cycle, 'symbol': symbol, 'sample': '一级',
'marketIndex': '',
'otherPar': ''}
self = indexScore_fund(btParms, fundAdjNav, 'auto')
op = self.output
val = op['factorValue']
allIndicators.append(val)
updatedType.append(fundType)
df = pd.DataFrame(allIndicators).fillna(bus_const.blank)
cols = df.columns.tolist()
for col in cols:
res = df[col]
lst = res.values.tolist()
lst = [transformFloatIfAvaliable(l) for l in lst]
objId = uuid_util.gen_uuid()
lst.insert(0, str(objId))
lst.insert(1, str(indicatorId))
lst.insert(2, col)
date = formatDate2yyyymmdd()
lst.insert(3, str(date))
lst.append("sys")
lst.append(datetime.datetime.now())
lst.append("sys")
lst.append(datetime.datetime.now())
tp = tuple(lst)
sql = "INSERT INTO fof_index_value (`OBJECT_ID`, `INDICATOR_ID`, `J_WINDCODE`, `TRADE_DT`, `THISYEAR_VALUE`, `QUARTER_VALUE`, `HALFYEAR_VALUE`, `YEAR_VALUE`, `TWOYEA_VALUE`, `THREEYEAR_VALUE`, `FIVEYEAR_VALUE`, `N1_VALUE`, `N2_VALUE`, `CREATE_USER_ID`, `CREATE_TIME`, `UPDATE_USER_ID`, `UPDATE_TIME`, `DELETE_FLAG`) VALUES ( %s, %s, %s, %s, %s, %s,%s,%s, %s,%s, %s, %s, %s, %s, %s, %s, %s,0)"
mysqlops.insert_one(MysqlConf.DB.fof, sql, tp)
allIndicators.clear()
def volatility(model: OfflineTaskModel):
# 离线计算年化波动率
if del_data('fof_variance') == False:
raise Error("删除历史数据失败，任务结束")
indicatorInfo = model.taskModel
taskName = indicatorInfo.value[0]
indiId = get_indicator_id(taskName)
# fundAdjNav = getPublicData(['股票型', '混合型'])
fundAdjNav = getPublicData()
fundSymbols = list(fundAdjNav.columns)
fundClass_1 = pd.Series('混合型基金', index=fundSymbols)
fundClass_tmp = getData_fundInformation(fundSymbols)['FUND_INVESTTYPE']
fundClass_1[fundClass_tmp.index] = fundClass_tmp
halfs = indicatorInfo.value[1]
for half in halfs:
updatedType = []
allIndicators = []
for symbol in fundSymbols:
fundType = fundClass_1[symbol]
if fundType not in updatedType:
for cycle in n_cycle_tp:
btParms = {'indexName': taskName, 'cycle': cycle, 'symbol': symbol, 'sample': '一级',
'marketIndex': '',
'otherPar': half}
self = indexScore_fund(btParms, fundAdjNav, 'auto')
op = self.output
val = op['factorValue']
allIndicators.append(val)
updatedType.append(fundType)
df = pd.DataFrame(allIndicators).fillna(bus_const.blank)
cols = df.columns.tolist()
for col in cols:
res = df[col]
lst = res.values.tolist()
lst = [transformFloatIfAvaliable(l) for l in lst]
objId = uuid_util.gen_uuid()
lst.insert(0, str(objId))
lst.insert(1, str(indiId))
lst.insert(2, str(col))
date = formatDate2yyyymmdd()
lst.insert(3, str(date))
lst.insert(4, transformString2Decimal(half))
lst.append("sys")
lst.append(datetime.datetime.now())
lst.append("sys")
lst.append(datetime.datetime.now())
tp = tuple(lst)
sql = "INSERT INTO fof_variance (`OBJECT_ID`, `INDICATOR_ID`, `J_WINDCODE`, `TRADE_DT`, `F_WEIGHT`, `THISYEAR_VALUE`, `QUARTER_VALUE`, `HALFYEAR_VALUE`, `YEAR_VALUE`, `TWOYEA_VALUE`, `THREEYEAR_VALUE`, `FIVEYEAR_VALUE`, `N1_VALUE`, `N2_VALUE`, `CREATE_USER_ID`, `CREATE_TIME`, `UPDATE_USER_ID`, `UPDATE_TIME`, `DELETE_FLAG`) VALUES ( %s, %s, %s, %s, %s, %s, %s,%s, %s, %s, %s, %s, %s, %s, %s, %s, %s,%s,0)"
mysqlops.insert_one(MysqlConf.DB.fof, sql, tp)
allIndicators.clear()
def industry_config_score(model):
# sql = "delete from fof_fund_industry_score "
# mysqlops.fetch_one(MysqlConf.DB.fof, sql)
if not del_data('fof_fund_industry_score'):
raise Error("删除历史数据失败，任务结束")
# 为提高运行速度，公共数据一次性提取，并作为参数传入要调用的类
stockIndus, indusNet = getPublicDataAllocation()
# 批量生成基金经理任职区间信息
managerInfo = getData_fundManagerInfo_all()
fundSymbols = getData_fundSymbols(['股票型', '混合型'])
tmp = []
for row in managerInfo.index:
if managerInfo.loc[row, 'fund'] in fundSymbols:
tmp.append(managerInfo.loc[row].to_dict())
managerInfo = pd.DataFrame(tmp, columns=managerInfo.columns)
'''
首次存入数据库时需要全部运行，后续更新维护时只需更新在任基金经理信息即可
'''
# 批量生成基金经理行业配置能力
for i in range(len(managerInfo)):
btParms = {
'symbol': managerInfo.loc[i, 'fund'],
'manager': managerInfo.loc[i, 'manager']
}
try:
test = industryAllocation_manager(btParms, stockIndus, indusNet)
output = test.output
scoreDF = output['alloScore'] # fof_fund_industry_score
for j, v in scoreDF.items():
sVal = v # 配置占股票市值比
dt_ = j # 时间
id_ = uuid_util.gen_uuid() # objId
wCode = output['symbol'] # 基金代码
lst = []
lst.append(id_)
lst.append(wCode)
lst.append(output['managerId'])
lst.append(output['manager'])
lst.append(dt_._short_repr.replace("-", ""))
lst.append(transformFloatIfAvaliable4(sVal))
lst.append("sys")
lst.append(datetime.now())
lst.append("sys")
lst.append(datetime.now())
sql = "INSERT INTO `fof`.`fof_fund_industry_score`(`OBJECT_ID`, `J_WINDCODE`, `MANAGER_ID`,`MANAGER_NAME`,`TRADE_DT`, `RETURN_SCORE`, `CREATE_USER_ID`, `CREATE_TIME`, `UPDATE_USER_ID`, `UPDATE_TIME`) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s)"
mysqlops.insert_one(MysqlConf.DB.fof, sql, tuple(lst))
except:
pass
def maximum_drawdown(request):
"""
离线计算最大回撤
:param request:
:return:
"""
uuid = uuid_util.gen_uuid()
model = OfflineTaskModel(TaskModel.zuidahuiche, offline_value_service.maximum_drawdown, request, uuid)
ThreadTool.pool.submit(logic_processor.doLogic, (model,))
view = OffLineView(uuid)
return JsonResponse(convert_to_dict(view))
def risk_single(request):
"""
风险因子业绩归因模块 fof_single_attr_riskmodel
:param request:
:return:
"""
uuid = uuid_util.gen_uuid()
model = OfflineTaskModel(TaskModel.stockRiskSingle,
offline_index_service.risk_single, request, uuid)
ThreadTool.pool.submit(logic_processor.doLogic, (model, ))
view = OffLineView(uuid)
return JsonResponse(convert_to_dict(view))
def stockexpousre(request):
"""
导入因子库
:param request:
:return:
"""
uuid = uuid_util.gen_uuid()
model = OfflineTaskModel(TaskModel.stockexpousre,
offline_index_service.stockexpousre, request,
uuid)
ThreadTool.pool.submit(logic_processor.doLogic, (model, ))
view = OffLineView(uuid)
return JsonResponse(convert_to_dict(view))
def calmar_ratio(request):
"""
离线计算卡玛比率
:param request:
:return:
"""
uuid = uuid_util.gen_uuid()
model = OfflineTaskModel(TaskModel.kamabilv, offline_value_service.calmar_ratio, request, uuid)
ThreadTool.pool.submit(logic_processor.doLogic, (model,))
view = OffLineView(uuid)
return JsonResponse(convert_to_dict(view))
def volatility(request):
"""
离线计算年化波动率
:param request:
:return:
"""
uuid = uuid_util.gen_uuid()
model = OfflineTaskModel(TaskModel.nianhuabodonglv, offline_value_service.volatility, request, uuid)
ThreadTool.pool.submit(logic_processor.doLogic, (model,))
view = OffLineView(uuid)
return JsonResponse(convert_to_dict(view))
def intervalYield(request):
"""
离线计算区间收益率
:return:
"""
uuid = uuid_util.gen_uuid()
model = OfflineTaskModel(TaskModel.qujianshouyilv, offline_value_service.interval_yield, request, uuid)
ThreadTool.pool.submit(logic_processor.doLogic, model)
view = OffLineView(uuid)
return JsonResponse(convert_to_dict(view))
def equ_timing(model):
if not del_data('fof_fund_timing'):
raise Error("删除历史数据失败，任务结束")
managerInfo = getData_fundManagerInfo_all()
fundSymbols = getData_fundSymbols(['股票型', '混合型'])
tmp = []
for row in managerInfo.index:
if managerInfo.loc[row, 'fund'] in fundSymbols:
tmp.append(managerInfo.loc[row].to_dict())
managerInfo = pd.DataFrame(tmp, columns=managerInfo.columns)
# 批量生成基金经理行业配置能力
for i in range(len(managerInfo)):
try:
btParms = {
'symbol': managerInfo.loc[i, 'fund'],
'manager': managerInfo.loc[i, 'manager']
}
test = equityTimingAbility_manager(btParms)
output = test.output
timing = output['hisTiming']
lst = timing.values.tolist()
for ls in lst:
ll = []
id_ = uuid_util.gen_uuid()
ll.append(id_)
ll.append(output['symbol'])
ll.append(output['managerId'])
ll.append(output['manager'])
ll.append(ls[0]) # start
ll.append(ls[1]) # end
ll.append(transformFloatIfAvaliable(ls[2])) # RISING
ll.append(transformFloatIfAvaliable(ls[3])) # HOLDINGS_BEGIN
ll.append(transformFloatIfAvaliable(ls[4])) # HOLDINGS_END
ll.append(transformFloatIfAvaliable(ls[5])) # TIMING_RESULT
ll.append(transformFloatIfAvaliable(ls[6])) # HOLDINGS_RATIO
ll.append(transformFloatIfAvaliable(output['winRatio']))
ll.append(transformFloatIfAvaliable4(output['avgTimingContr']))
ll.append("sys")
ll.append(datetime.now())
ll.append("sys")
ll.append(datetime.now())
sql = "INSERT INTO `fof`.`fof_fund_timing`(`OBJECT_ID`, `J_WINDCODE`, `MANAGER_ID`, `MANAGER_NAME`, `START_DATE`, `END_DATE`, `RISING`, `HOLDINGS_BEGIN`, `HOLDINGS_END`, `TIMING_RESULT`, `HOLDINGS_RATIO`,`TIMING_WIN_RATIO`,`AVG_CONTRIBUTION`, `CREATE_USER_ID`, `CREATE_TIME`, `UPDATE_USER_ID`, `UPDATE_TIME`) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)"
insert_one(MysqlConf.DB.fof, sql, tuple(ll))
except:
pass
def stockexpousre(model):
# factorName即为mongodb数据库相关collection的名字，一次仅支持传入一个因子值
sql = "delete from fof_stockexpousre "
mysqlops.fetch_one(MysqlConf.DB.fof, sql)
if not del_data('fof_stockexpousre'):
raise Error("删除历史数据失败，任务结束")
fs = [
'value',
'size',
'beta',
'earning',
# 'factorReturn',
'growth',
'leverage',
'liquidity',
'momentum',
'nonlinear_size',
'size',
'volatility'
]
sql = 'insert into ' \
'fof_stockexpousre (OBJECT_ID,trade_dt,s_windcode,indicator_code,factor_value,CREATE_USER_ID,CREATE_TIME,UPDATE_USER_ID,UPDATE_TIME)' \
'values (%s,%s,%s,%s,%s,%s,%s,%s,%s)'
for fName in fs:
valueExp = getData_factorExposure(fName)
valueExp = valueExp.fillna("9999.000000")
di = valueExp.to_dict()
for k in di:
# print("K===%s" % k)
for v in di.get(k):
s = uuid_util.gen_uuid()
lsd = []
oid = s[:5] + '-' + s[5:9] + '-' + s[9:13] + '-' + s[
13:18] + '-' + s[18:]
lsd.append(oid)
r = v._date_repr.replace("-", "")
lsd.append(r)
lsd.append(k[:-2] + "." + k[-2:])
lsd.append(fName)
lsd.append(transformFloatIfAvaliable(di.get(k).get(v)))
lsd.append("sys")
lsd.append(datetime.now())
lsd.append("sys")
lsd.append(datetime.now())
mysqlops.insert_one(MysqlConf.DB.fof, sql, tuple(lsd))
def return_his(request):
"""
基金经理股票筛选能力
table: fof_fund_main_stock_return_his
:param request:
:return:
"""
uuid = uuid_util.gen_uuid()
model = OfflineTaskModel(TaskModel.jingliShaixuanNengli_return_his,
manager_service.return_his, request, uuid)
ThreadTool.pool.submit(logic_processor.doLogic, (model, ))
view = OffLineView(uuid)
return JsonResponse(convert_to_dict(view))
def net_value(request):
"""
基金净值风格划分 fof_fundnav_style
考虑到服务器的承载能力，该程序前期可每周更新，后续服务器运载能力加大，可改为每日更新
:param request:
:return:
"""
uuid = uuid_util.gen_uuid()
model = OfflineTaskModel(TaskModel.jinglifengge_profit_style,
manager_service.net_value, request, uuid)
ThreadTool.pool.submit(logic_processor.doLogic, (model, ))
view = OffLineView(uuid)
return JsonResponse(convert_to_dict(view))
def compute_manager_product(request, format=None):
"""
计算基金经理管理的产品信息
:param request:
:return:
"""
uuid = uuid_util.gen_uuid()
model = OfflineTaskModel(TaskModel.jinglichanpin,
manager_service.compute_manager_product, request,
uuid)
ThreadTool.pool.submit(logic_processor.doLogic, (model, ))
view = OffLineView(uuid)
return JsonResponse(convert_to_dict(view))
def holding_style_all(request):
"""
风格分析 - 持仓风格
fof_fund_stock_style
:param request:
:return:
"""
uuid = uuid_util.gen_uuid()
model = OfflineTaskModel(TaskModel.jinglifengge_holding_stype_all,
manager_service.holding_style_all, request, uuid)
ThreadTool.pool.submit(logic_processor.doLogic, (model, ))
view = OffLineView(uuid)
return JsonResponse(convert_to_dict(view))
def equ_timing(request):
"""
基金经理股票择时能力评价模型
请于每季结束后的第一个月的15日开始运行本程序(即基金季报发布)，按日更新，运行至该月末
如1季度结束后，于4月15日~4月30日每日更新该数据
:param request:
:return:
"""
uuid = uuid_util.gen_uuid()
model = OfflineTaskModel(TaskModel.jingliNengli,
manager_service.equ_timing, request, uuid)
ThreadTool.pool.submit(logic_processor.doLogic, (model, ))
view = OffLineView(uuid)
return JsonResponse(convert_to_dict(view))
def holding_style_main(request):
"""
风格分析-持仓风格 fof_fund_tentop_stock_style
重仓股数风格暴露数据，请于每季结束后的第一个月的15日开始运行本程序，按日更新，运行至该月末
全部持仓数据，请于每年的8月21日~8月31日，以及3月21日~3月31日运行
:param request:
:return:
"""
uuid = uuid_util.gen_uuid()
model = OfflineTaskModel(TaskModel.jinglifengge_holding_stype_main,
manager_service.holding_style_main, request, uuid)
ThreadTool.pool.submit(logic_processor.doLogic, (model, ))
view = OffLineView(uuid)
return JsonResponse(convert_to_dict(view))
def industry_config_score(request):
"""
离线计算基金经理行业配置能力
:keyword 表 fof_fund_industry_score
请于每季结束后的第一个月的15日开始运行本程序(即基金季报发布)，按日更新，运行至该月末
如1季度结束后，于4月15日~4月30日每日更新该数据
:param request:
:return:
"""
uuid = uuid_util.gen_uuid()
model = OfflineTaskModel(TaskModel.jingliPeizhiNengli_score,
manager_service.industry_config_score, request,
uuid)
ThreadTool.pool.submit(logic_processor.doLogic, (model, ))
view = OffLineView(uuid)
return JsonResponse(convert_to_dict(view))
def hand_turn_over(request):
"""
能力分析-持股集中度、换手率 fof_fund_stock_porfolio
该程序于每半年进行一次更新
请于每年的3月20日~3月31日以及8月20日~8月31日更新
由于程序运行量不大，若更新时间配置麻烦，可设定为每日更新
:param request:
:return:
"""
uuid = uuid_util.gen_uuid()
model = OfflineTaskModel(TaskModel.jinglifengge_hand_change_rate,
manager_service.hand_turn_over, request, uuid)
ThreadTool.pool.submit(logic_processor.doLogic, (model, ))
view = OffLineView(uuid)
return JsonResponse(convert_to_dict(view))
def net_value(model):
if not del_data('fof_fundnav_style'):
raise Error("删除历史数据失败，任务结束")
# 基金净值风格划分 fof_fundnav_style
fundSymbols = getData_fundSymbols(['股票型', '混合型'])
# fundSymbols=fundSymbols[0:20] #生产环境删除此句
output_all = []
i = 0
for symbol in fundSymbols:
i += 1
btParms = {'symbol': symbol, 'cycle': '成立以来'} # 离线入库时cycle设定为"成立以来"即可
test = fundStyle_nav(btParms)
output = test.output
tmp = output['regStat']
if tmp is None or len(tmp) == 0:
continue
for idx in tmp.index:
di = tmp.loc[idx].to_dict()
startDate = di['startDate']
endDate = di['endDate']
largeCoe = di['largeCoeff']
smallCoe = di['smallCoeff']
r2 = di['R2']
lst = []
id_ = uuid_util.gen_uuid() # objId
lst.append(id_)
lst.append(output['symbol'])
lst.append(startDate)
lst.append(endDate)
lst.append(largeCoe)
lst.append(smallCoe)
lst.append(r2)
lst.append("sys")
lst.append(datetime.now())
lst.append("sys")
lst.append(datetime.now())
ll = [transformFloatIfAvaliable4(j) for j in lst]
sql = "INSERT INTO `fof`.`fof_fundnav_style`(`OBJECT_ID`, `J_WINDCODE`, `START_DATE`, `END_DATE`, `LARGE_COEFFICIENTS`, `SMALL_COEFFICIENTS`,`R2`, `CREATE_USER_ID`, `CREATE_TIME`, `UPDATE_USER_ID`, `UPDATE_TIME`) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s,%s, %s)"
mysqlops.insert_one(MysqlConf.DB.fof, sql, tuple(ll))
def holding_style_main(model):
if not del_data('fof_fund_tentop_stock_style'):
raise Error("删除历史数据失败，任务结束")
# 获取本模块公共数据
factorExposure = publicData_stockFactor()
fundSymbols = getData_fundSymbols(['股票型', '混合型'])
# fundSymbols = fundSymbols[0:10] # 生产环境删除此句
typeList = ['mainStockHolding', 'allStockHolding']
# 暴露度计算
# for holdingType in typeList:
for symbol in fundSymbols:
btParms = {'symbol': symbol, 'holdingType': 'mainStockHolding'}
test = fundFactorExposure(btParms, factorExposure)
output = test.output
tmp = output['hisExposure']
# if holdingType == 'mainStockHolding':
# 10 top
for time in tmp:
val = tmp[time]
for idx in val.index:
di = val.loc[idx].to_dict()
exp = di['portExposure']
expscore = di['portExposureScore']
ls = []
ls.append(uuid_util.gen_uuid())
ls.append(output['symbol'])
ls.append(time._short_repr.replace("-", ""))
ls.append(idx)
ls.append(transformFloatIfAvaliable3(exp))
ls.append(transformFloatIfAvaliable3(expscore))
ls.append("sys")
ls.append(datetime.now())
ls.append("sys")
ls.append(datetime.now())
sql = "INSERT INTO `fof`.`fof_fund_tentop_stock_style`(`OBJECT_ID`, `J_WINDCODE`, `TRADE_DT`, `INDICATOR_NAME`, `EXPOSE_VALUE`, `EXPOSE_SCORE`, `CREATE_USER_ID`, `CREATE_TIME`, `UPDATE_USER_ID`, `UPDATE_TIME`) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s)"
mysqlops.insert_one(MysqlConf.DB.fof, sql, tuple(ls))
