def eod_hst_pnl_run(pricing_environment):
r = utils.get_redis_conn(ip)
position_result = r.get(EOD_CUSTOM_POSITION_ + pricing_environment.lower())
position = JSONDecoder().decode(bytes.decode(position_result))
cash_flow_result = r.get(EOD_BASIC_CASH_FLOW)
cash_flow = JSONDecoder().decode(bytes.decode(cash_flow_result))
underlyer_position_result = r.get(EOD_BASIC_UNDELRYER_POSITION_ +
pricing_environment.lower())
underlyer_position = JSONDecoder().decode(
bytes.decode(underlyer_position_result))
position_map_result = r.get(EOD_BASIC_POSITION_MAP)
position_map = JSONDecoder().decode(bytes.decode(position_map_result))
headers = utils.login(ip, login_body)
pe_description = get_pricing_environment_description(
pricing_environment, headers)
reports = eod_historical_pnl_by_underlyer_report(position, cash_flow,
underlyer_position,
position_map,
pe_description)
hst_pnl_result = JSONEncoder().encode(reports)
r.set(EOD_CUSTOM_HST_PNL_ + pricing_environment.lower(),
str(hst_pnl_result))
now_date = datetime.now().date()
params = {
'reportName': HST_PNL_REPORT_ + pe_description,
'valuationDate': str(now_date),
'pnlHstReports': reports
}
utils.call_request(ip, 'report-service', 'rptPnlHstReportCreateBatch',
params, headers)
def eod_market_risk_detail_default_close_pd_run(valuation_date):
r = utils.get_redis_conn(redis_ip)
position_result = r.get(EOD_CUSTOM_POSITION_ + PE_DEFAULT_CLOSE.lower())
position = JSONDecoder().decode(bytes.decode(position_result))
if position:
headers = utils.login(data_resource_ip, login_body)
reports = eod_market_risk_detail_report_pd.eod_market_risk_detail_report(
pd.DataFrame(position))
instrument_contract_result = r.get(EOD_BASIC_INSTRUMENT_CONTRACT_TYPE)
instruments_contract_dict = JSONDecoder().decode(
bytes.decode(instrument_contract_result))
for item in reports:
item['exfsid'] = instruments_contract_dict.get(
item.get('underlyerInstrumentId'))
params = {
'reportName': '全市场分品种风险报告_交易-收盘-自然日',
'valuationDate': valuation_date,
'reports': reports
}
utils.call_request(report_ip, 'report-service',
'rptMarketRiskDetailReportCreateBatch', params,
headers)
def eod_counter_party_market_risk_by_underlyer_default_close_pd_run(
valuation_date):
r = utils.get_redis_conn(redis_ip)
position_result = r.get(EOD_CUSTOM_POSITION_ + PE_DEFAULT_CLOSE.lower())
position = JSONDecoder().decode(bytes.decode(position_result))
if position:
sub_companies_result = r.get(EOD_BASIC_SUB_COMPANIES_FROM_ORACLE)
all_sub_companies = JSONDecoder().decode(
bytes.decode(sub_companies_result))
headers = utils.login(data_resource_ip, login_body)
reports = eod_market_risk_summary_report_pd.eod_counter_party_market_risk_by_underlyer_report(
pd.DataFrame(position), all_sub_companies)
instrument_contract_result = r.get(EOD_BASIC_INSTRUMENT_CONTRACT_TYPE)
instruments_contract_dict = JSONDecoder().decode(
bytes.decode(instrument_contract_result))
for item in reports:
item['exfsid'] = instruments_contract_dict.get(
item.get('underlyerInstrumentId'))
params = {
'reportName': '交易对手分品种风险报告_交易-收盘-自然日',
'valuationDate': valuation_date,
'reports': reports
}
utils.call_request(
report_ip, 'report-service',
'rptCounterPartyMarketRiskByUnderlyerReportCreateBatch', params,
headers)
def intraday_report_notifier(notification_type):
r = utils.get_redis_conn(ip)
valuation_time = str(datetime.now().isoformat())
msg = {"reportType": notification_type, "valuationTime": valuation_time}
msg_json = JSONEncoder().encode(msg)
r.set(INTRADAY_NOTIFY, str(msg_json))
r.publish(INTRADAY_NOTIFY, str(msg_json))
def eod_position_run(pricing_environment):
r = utils.get_redis_conn(ip)
position_result = r.get(EOD_BASIC_POSITIONS)
position = JSONDecoder().decode(bytes.decode(position_result))
risk_result = r.get(EOD_BASIC_RISKS_ + pricing_environment.lower())
risk = JSONDecoder().decode(bytes.decode(risk_result))
cash_flow_result = r.get(EOD_BASIC_CASH_FLOW)
cash_flow = JSONDecoder().decode(bytes.decode(cash_flow_result))
headers = utils.login(ip, login_body)
reports = eod_position_report(position, risk, cash_flow,
pricing_environment, ip, headers)
position_result = JSONEncoder().encode(reports)
r.set(EOD_CUSTOM_POSITION_ + pricing_environment.lower(),
str(position_result))
now_date = datetime.now().date()
pe_description = get_pricing_environment_description(
pricing_environment, headers)
params = {
'reportName': POSITION_REPORT_ + pe_description,
'valuationDate': str(now_date),
'positionReports': reports
}
utils.call_request(ip, 'report-service', 'rptPositionReportCreateBatch',
params, headers)
def eod_market_risk_by_book_underlyer_pd_run(pricing_environment,
valuation_date):
r = utils.get_redis_conn(redis_ip)
position_result = r.get(EOD_CUSTOM_POSITION_ + pricing_environment.lower())
position = JSONDecoder().decode(bytes.decode(position_result))
if position:
headers = utils.login(data_resource_ip, login_body)
pe_description = utils.get_pricing_env_description(
pricing_environment, data_resource_ip, headers)
reports = eod_market_risk_by_book_underlyer_report_pd.eod_market_risk_by_book_underlyer_report(
pd.DataFrame(position), pe_description)
instrument_contract_result = r.get(EOD_BASIC_INSTRUMENT_CONTRACT_TYPE)
instruments_contract_dict = JSONDecoder().decode(
bytes.decode(instrument_contract_result))
for item in reports:
item['exfsid'] = instruments_contract_dict.get(
item.get('underlyerInstrumentId'))
params = {
'reportName':
MARKET_RISK_BY_BOOK_UNDERLYER_REPORT_ + pe_description,
'valuationDate': valuation_date,
'reports': reports
}
utils.call_request(report_ip, 'report-service',
'rptMarketRiskBySubUnderlyerReportCreateBatch',
params, headers)
def eod_position_pd_run(pricing_environment, valuation_date):
r = utils.get_redis_conn(redis_ip)
position_result = r.get(EOD_BASIC_POSITIONS)
position = pd.read_msgpack(position_result)
risk_result = r.get(EOD_BASIC_RISKS_ + pricing_environment.lower())
risk = pd.read_msgpack(risk_result)
cash_flow_result = r.get(EOD_BASIC_CASH_FLOW)
cash_flow = pd.read_msgpack(cash_flow_result)
listed_option_positions_result = r.get(EOD_BASIC_LISTED_OPTION_POSITION_ +
pricing_environment.lower())
listed_option_positions = pd.read_msgpack(listed_option_positions_result)
headers = utils.login(data_resource_ip, login_body)
rpt = []
if not position.empty:
rpt = eod_position_report_pd.eod_position_report(
position, risk, cash_flow, listed_option_positions,
pricing_environment, data_resource_ip, headers, valuation_date)
position_result = JSONEncoder().encode(rpt)
r.set(EOD_CUSTOM_POSITION_ + pricing_environment.lower(),
str(position_result))
def eod_classic_scenarios_pd_run(valuation_date):
r = utils.get_redis_conn(redis_ip)
position_result = r.get(EOD_BASIC_POSITIONS)
position = pd.read_msgpack(position_result)
if not position.empty:
sub_companies_result = r.get(EOD_BASIC_SUB_COMPANIES_FROM_ORACLE)
all_sub_companies = JSONDecoder().decode(
bytes.decode(sub_companies_result))
headers = utils.login(data_resource_ip, login_body)
pe_description = utils.get_pricing_env_description(
PE_DEFAULT_CLOSE, data_resource_ip, headers)
reports = eod_classic_scenarios_report_pd.eod_classic_scenarios_report(
position, all_sub_companies, data_resource_ip, headers,
valuation_date, PE_DEFAULT_CLOSE)
instrument_contract_result = r.get(EOD_BASIC_INSTRUMENT_CONTRACT_TYPE)
instruments_contract_dict = JSONDecoder().decode(
bytes.decode(instrument_contract_result))
for item in reports:
item['exfsid'] = instruments_contract_dict.get(
item.get('underlyerInstrumentId'))
params = {
'reportName':
CLASSIC_SCENARIO_MARKET_RISK_REPORT_ + pe_description,
'valuationDate': valuation_date,
'reports': reports
}
utils.call_request(report_ip, 'report-service',
'rptMarketRiskDetailReportCreateBatch', params,
headers)
def basic_cash_flow_run():
headers = utils.login(ip, login_body)
cash_flow = get_cash_flow(ip, headers)
cash_flow_result = JSONEncoder().encode(cash_flow)
r = utils.get_redis_conn(ip)
r.set(EOD_BASIC_CASH_FLOW, str(cash_flow_result))
print('Basic CashFlow Data Has Save To Redis')
def basic_cash_flow_pd_run():
headers = utils.login(ip, login_body)
cash_flow = basic_cashflows_pd.get_cash_flow(ip, headers)
cash_flow_result = cash_flow.to_msgpack(compress='zlib')
r = utils.get_redis_conn(redis_ip)
r.set(INTRADAY_BASIC_CASH_FLOW, cash_flow_result)
print('Basic CashFlow Pd Data Has Save To Redis')
def basic_portfolio_trades_run():
headers = utils.login(ip, login_body)
portfolio_trades = basic_portfolios.get_portfolio_trades(ip, headers)
portfolio_trades_result = JSONEncoder().encode(portfolio_trades)
r = utils.get_redis_conn(ip)
r.set(INTRADAY_BASIC_PORTFOLIO_TRADES, str(portfolio_trades_result))
print('Basic portfolioTrades Data Has Save To Redis')
def basic_portfolio_trades_pd_run():
headers = utils.login(ip, login_body)
portfolio_trades = basic_portfolios_pd.get_portfolio_trades(ip, headers)
portfolio_trades_result = portfolio_trades.to_msgpack(compress='zlib')
r = utils.get_redis_conn(redis_ip)
r.set(INTRADAY_BASIC_PORTFOLIO_TRADES, portfolio_trades_result)
print('Basic portfolioTrades Pd Data Has Save To Redis')
def basic_cash_flow_today_run():
headers = utils.login(ip, login_body)
cash_flow_today = basic_cashflows.get_cash_flows_today(ip, headers)
cash_flow_today_result = JSONEncoder().encode(cash_flow_today)
r = utils.get_redis_conn(ip)
r.set(INTRADAY_BASIC_CASH_FLOW_TODAY, str(cash_flow_today_result))
print('Basic CashFlowToday Data Has Save To Redis')
def basic_instrument_contract_type_run():
instrument_contract_dict = basic_instrument_contract_type.get_instrument_contract_dict(
)
r = utils.get_redis_conn(redis_ip)
r.set(EOD_BASIC_INSTRUMENT_CONTRACT_TYPE,
JSONEncoder().encode(instrument_contract_dict))
print(
' Basic instrument contract type Info from terminal postgres Has Save To Redis'
)
def get_basic_underlyer_position(price_env):
headers = utils.login(ip, login_body)
underlyer_position = get_underlyer_positions(ip, headers, price_env)
underlyer_position_result = JSONEncoder().encode(underlyer_position)
r = utils.get_redis_conn(ip)
r.set(EOD_BASIC_UNDELRYER_POSITION_ + price_env.lower(),
str(underlyer_position_result))
print(price_env + ' Basic UnderlyerPosition Data Has Save To Redis')
def basic_cash_flow_today_pd_run():
headers = utils.login(data_resource_ip, login_body)
# cash_flow_today = basic_cashflows_pd.get_cash_flows_today(data_resource_ip, headers)
cash_flow_today = pd.DataFrame()
cash_flow_today_result = cash_flow_today.to_msgpack(compress='zlib')
r = utils.get_redis_conn(redis_ip)
r.set(EOD_BASIC_CASH_FLOW_TODAY, cash_flow_today_result)
print('Basic CashFlowToday Pd Data Has Save To Redis')
def basic_underlyer_position_run():
headers = utils.login(ip, login_body)
underlyer_position = basic_listed_positions.get_underlyer_positions(
ip, headers, PE_DEFAULT_INTRADAY)
underlyer_position_result = JSONEncoder().encode(underlyer_position)
r = utils.get_redis_conn(ip)
r.set(INTRADAY_BASIC_UNDELRYER_POSITION, str(underlyer_position_result))
print('Basic UnderlyerPosition Data Has Save To Redis')
def basic_position_run():
headers = utils.login(ip, login_body)
position, expiring_pos, position_map = get_positions(ip, headers)
position_map_result = JSONEncoder().encode(position_map)
position_result = JSONEncoder().encode(position)
r = utils.get_redis_conn(ip)
r.set(EOD_BASIC_POSITIONS, str(position_result))
r.set(EOD_BASIC_POSITION_MAP, str(position_map_result))
print('Basic Position Data Has Save To Redis')
def basic_risks_run(pricing_environment):
headers = utils.login(ip, login_body)
valuation_time = datetime.now()
r = utils.get_redis_conn(ip)
position_result = r.get(EOD_BASIC_POSITIONS)
position = JSONDecoder().decode(bytes.decode(position_result))
risk, price_data = get_risks([position], pricing_environment,
valuation_time, ip, headers)
risk_result = JSONEncoder().encode(risk)
r.set(EOD_BASIC_RISKS_ + pricing_environment.lower(), str(risk_result))
print('Basic Risk Data In ' + pricing_environment + ' Has Save To Redis')
def basic_otc_company_type_run():
sub_companies = basic_otc_company_type.get_sub_company_from_oracle()
sub_companies_name = list(
set(map(lambda i: i.get('clientName'), sub_companies)))
r = utils.get_redis_conn(redis_ip)
r.set(EOD_BASIC_SUB_COMPANIES_FROM_ORACLE,
JSONEncoder().encode(sub_companies_name))
print(' Basic SubCompanies Info from Oracle Has Save To Redis')
headers = utils.login(data_resource_ip, login_body)
params = {"infos": sub_companies}
utils.call_request(report_ip, 'reference-data-service',
'refCompanyTypeInfoBatchCreate', params, headers)
def basic_position_pd_run(valuation_date):
headers = utils.login(data_resource_ip, login_body)
position, position_map = basic_positions_pd.get_eod_positions(
data_resource_ip, headers, valuation_date)
position_result = position.to_msgpack(compress='zlib')
position_map_result = position_map.to_msgpack(compress='zlib')
r = utils.get_redis_conn(redis_ip)
r.set(EOD_BASIC_POSITIONS, position_result)
r.set(EOD_BASIC_POSITION_MAP, position_map_result)
print('Basic Position Pd Data Has Save To Redis')
def basic_position_run():
headers = utils.login(ip, login_body)
position, expiring, position_index = basic_positions.get_intraday_positions(
ip, headers)
position_index_result = JSONEncoder().encode(position_index)
position_result = JSONEncoder().encode(position)
expiring_result = JSONEncoder().encode(expiring)
r = utils.get_redis_conn(ip)
r.set(INTRADAY_BASIC_EXPIRING, str(expiring_result))
r.set(INTRADAY_BASIC_POSITIONS, str(position_result))
r.set(INTRADAY_BASIC_POSITION_INDEX, str(position_index_result))
print('Basic Position Data Has Save To Redis')
def basic_risks_pd_run(pricing_environment, valuation_date):
headers = utils.login(data_resource_ip, login_body)
r = utils.get_redis_conn(redis_ip)
position_result = r.get(EOD_BASIC_POSITIONS)
position = pd.read_msgpack(position_result)
if not position.empty:
risk = basic_risks_pd.get_risks(position, pricing_environment,
valuation_date, data_resource_ip,
headers)
risk_result = risk.to_msgpack(compress='zlib')
r.set(EOD_BASIC_RISKS_ + pricing_environment.lower(), risk_result)
print('Basic Risk Pd Data In ' + pricing_environment +
' Has Save To Redis')
def basic_underlyer_position_pd_run():
headers = utils.login(ip, login_body)
underlyer_positions, listed_option_positions = basic_listed_positions_pd.get_underlyer_positions(
ip, headers, PE_DEFAULT_INTRADAY)
underlyer_positions_result = underlyer_positions.to_msgpack(
compress='zlib')
listed_option_positions_result = listed_option_positions.to_msgpack(
compress='zlib')
r = utils.get_redis_conn(redis_ip)
r.set(INTRADAY_BASIC_UNDELRYER_POSITION, underlyer_positions_result)
r.set(INTRADAY_BASIC_LISTED_OPTION_POSITION,
listed_option_positions_result)
print('Basic UnderlyerPosition Pd Data Has Save To Redis')
def get_basic_underlyer_position_pd(price_env):
headers = utils.login(data_resource_ip, login_body)
underlyer_position, listed_option_positions = basic_listed_positions_pd.get_underlyer_positions(
data_resource_ip, headers, price_env)
underlyer_position_result = underlyer_position.to_msgpack(compress='zlib')
listed_option_positions_result = listed_option_positions.to_msgpack(
compress='zlib')
r = utils.get_redis_conn(redis_ip)
r.set(EOD_BASIC_UNDELRYER_POSITION_ + price_env.lower(),
underlyer_position_result)
r.set(EOD_BASIC_LISTED_OPTION_POSITION_ + price_env.lower(),
listed_option_positions_result)
print(price_env + ' Basic UnderlyerPosition Pd Data Has Save To Redis')
def basic_risks_run():
valuation_time = datetime.now()
pricing_environment = PE_DEFAULT_INTRADAY
headers = utils.login(ip, login_body)
r = utils.get_redis_conn(ip)
position_result = r.get(INTRADAY_BASIC_POSITIONS)
positions = JSONDecoder().decode(bytes.decode(position_result))
expiring_result = r.get(INTRADAY_BASIC_EXPIRING)
expirings = JSONDecoder().decode(bytes.decode(expiring_result))
risk = basic_risks.get_risks([positions, expirings], pricing_environment,
valuation_time, ip, headers)[0]
risk_result = JSONEncoder().encode(risk)
r.set(INTRADAY_BASIC_RISKS, str(risk_result))
print('Basic Risk Data Has Save To Redis')
def real_time_pnl_pd_run():
r = utils.get_redis_conn(redis_ip)
risk_result = r.get(INTRADAY_BASIC_RISKS)
risk = pd.read_msgpack(risk_result)
underlyer_position_result = r.get(INTRADAY_BASIC_UNDELRYER_POSITION)
underlyer_position = pd.read_msgpack(underlyer_position_result)
list_position_result = r.get(INTRADAY_BASIC_LISTED_OPTION_POSITION)
list_position = pd.read_msgpack(list_position_result)
cash_flow_today_result = r.get(INTRADAY_BASIC_CASH_FLOW_TODAY)
cash_flow_today = pd.read_msgpack(cash_flow_today_result)
live_position_index_result = r.get(INTRADAY_BASIC_POSITION_INDEX)
live_position_index = pd.read_msgpack(live_position_index_result)
today_terminated_position_index_result = r.get(
INTRADAY_BASIC_TERMINATED_POSITION_INDEX)
today_terminated_position_index = pd.read_msgpack(
today_terminated_position_index_result)
now_date = datetime.now().date()
yst_date = now_date + timedelta(days=-1)
yst_params = {
'reportName': POSITION_REPORT,
'valuationDate': str(yst_date)
}
headers = utils.login(ip, login_body)
yst_position = utils.call_request(ip, 'report-service',
'rptLatestPositionReportByNameAndDate',
yst_params, headers)['result']
yst_params['reportName'] = HST_PNL_REPORT
yst_historical_pnl = utils.call_request(
ip, 'report-service', 'rptLatestPnlHstReportByNameAndDate', yst_params,
headers)['result']
yst_position = pd.DataFrame(yst_position)
yst_historical_pnl = pd.DataFrame(yst_historical_pnl)
pe_description = utils.get_pricing_env_description(PE_DEFAULT_INTRADAY, ip,
headers)
reports = intraday_daily_pnl_by_underlyer_report_pd.intraday_daily_pnl_by_underlyer_report(
risk, cash_flow_today, underlyer_position, list_position,
live_position_index, today_terminated_position_index, yst_position,
yst_historical_pnl, pe_description)
reports = utils.remove_nan_and_inf(reports.to_dict(orient='records'))
pnl_result = JSONEncoder().encode(reports)
r.set(PNL_QUEUE, str(pnl_result))
r.publish(PNL_QUEUE, str(pnl_result))
def eod_statics_of_risk_run(price_environment):
headers = utils.login(ip, login_body)
r = utils.get_redis_conn(ip)
price_data = r.get(EOD_BASIC_RISKS_ + price_environment.lower())
price_data = JSONDecoder().decode(bytes.decode(price_data))
pe_description = get_pricing_environment_description(
price_environment, headers)
report = get_eod_statics_of_risk(price_data)
params = {
"reportName": '风险指标统计表_' + pe_description,
'reportType': RISK_REPORT_TYPE,
"valuationDate": time.strftime("%Y-%m-%d", time.localtime()),
"reports": [report]
}
utils.call_request(ip, 'report-service', 'rptCustomReportSaveBatch',
params, headers)
def real_time_expiring_position_run():
r = utils.get_redis_conn(ip)
position_result = r.get(INTRADAY_BASIC_EXPIRING)
position = JSONDecoder().decode(bytes.decode(position_result))
risk_result = r.get(INTRADAY_BASIC_RISKS)
risk = JSONDecoder().decode(bytes.decode(risk_result))
cash_flow_result = r.get(INTRADAY_BASIC_CASH_FLOW)
cash_flow = JSONDecoder().decode(bytes.decode(cash_flow_result))
reports = intraday_expiring_position_report(position, risk, cash_flow)
position_result = JSONEncoder().encode(reports)
r.set(TRADE_EXPIRING_QUEUE, str(position_result))
r.publish(TRADE_EXPIRING_QUEUE, str(position_result))
r.set(INTRADAY_CUSTOM_EXPIRING_POSITION, str(position_result))
def eod_market_risk_summary_run(pricing_environment):
r = utils.get_redis_conn(ip)
position_result = r.get(EOD_CUSTOM_POSITION_ + pricing_environment.lower())
position = JSONDecoder().decode(bytes.decode(position_result))
headers = utils.login(ip, login_body)
reports = eod_market_risk_summary_report(position, pricing_environment)
now_date = datetime.now().date()
pe_description = get_pricing_environment_description(
pricing_environment, headers)
params = {
'reportName': MARKET_RISK_REPORT_ + pe_description,
'valuationDate': str(now_date),
'reports': reports
}
utils.call_request(ip, 'report-service', 'rptMarketRiskReportCreateBatch',
params, headers)
