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)