Ejemplo n.º 1
0
 def import_atm_vol_from_csv_file(file_path, run_id):
     fname, ext = os.path.splitext(file_path)
     valuation_date = DateTimeUtils.str2date(fname.split('_')[1],
                                             pattern='%Y%m%d')
     df = pd.read_csv(file_path)
     atm_quote_list = []
     current_time = datetime.now()
     for index, row in df.iterrows():
         atm_quote = OtcAtmQuote()
         atm_quote.uuid = uuid.uuid4()
         atm_quote.varietyType = row['udly'].strip()
         atm_quote.underlyer = row['code'].strip()
         atm_quote.legalEntityName = row['ctpt'].strip()
         atm_quote.expireDate = DateTimeUtils.str2date(row['exe_date'])
         if row['type'] == 'am':
             atm_quote.productType = OptionProductType.VANILLA_AMERICAN.name
         if row['type'] == 'eu':
             atm_quote.productType = OptionProductType.VANILLA_EUROPEAN.name
         atm_quote.ptm = float(row['ptm'])
         atm_quote.askVol = float(row['ask_vol_cal'])
         atm_quote.bidVol = float(row['bid_vol_cal'])
         atm_quote.volEdge = float(row['vol_edge_cal'])
         atm_quote.source = 'EXCEL_%s' % run_id
         atm_quote.valuationDate = valuation_date
         atm_quote.updatedAt = current_time
         atm_quote_list.append(atm_quote)
     db_sessin = create_db_session()
     db_sessin.add_all(atm_quote_list)
     db_sessin.commit()
Ejemplo n.º 2
0
 def convert_data_to_position_snapshot(clean_position_dict):
     """
     格式化为otc_position_snapshot表model
     :param clean_position_dict:
     :return:
     """
     position_snapshots = []
     for trans_code, clean_position in clean_position_dict.items():
         # todo 需要删除continue
         if clean_position is None:
             continue
         report_date = DateTimeUtils.str2date(
             clean_position.get('report_date'))
         position_date = DateTimeUtils.str2date(
             clean_position.get('position_date'))
         item = OTCPositionSnapshot(
             transCode=clean_position.get('trans_code'),
             recordId=clean_position.get('record_id'),
             reportDate=report_date,
             positionDate=position_date,
             instrumentId=clean_position.get('underlyer'),
             mainBodyName=clean_position.get('main_body_name'),
             tradeNotional=clean_position.get('trade_notional'),
             impliedVol=clean_position.get('implied_vol'),
             interestRate=clean_position.get('interest_rate'),
             dividend=clean_position.get('dividend'),
             updatedAt=datetime.now())
         position_snapshots.append(item)
     return position_snapshots
Ejemplo n.º 3
0
 async def get_commodity_future_contract_order(self, variety_type,
                                               start_date, end_date):
     with self.make_session() as db_session:
         fc_info_list = CommodityFutureContractService.get_future_contract_order_dto(
             db_session, variety_type, [],
             DateTimeUtils.str2date(start_date),
             DateTimeUtils.str2date(end_date))
         fc_info_schema = FutureContractInfoSchema(many=True)
         return fc_info_schema.dump(fc_info_list).data
Ejemplo n.º 4
0
 async def get_historical_and_neutral_vol_list(self,
                                               instrument_ids,
                                               start_date,
                                               end_date,
                                               window,
                                               is_primary=False):
     with self.make_session() as db_session:
         start_date_obj = DateTimeUtils.str2date(start_date)
         end_date_obj = DateTimeUtils.str2date(end_date)
         neutral_vol_list, diagnostics = HistoricalVolService.calc_historical_and_neutral_vol_list(
             db_session, instrument_ids, start_date_obj, end_date_obj,
             window, is_primary)
     neutral_vol_schema = NeutralVolSchema(many=True)
     return DiagnosticResponse(
         neutral_vol_schema.dump(neutral_vol_list).data, diagnostics)
Ejemplo n.º 5
0
 async def get_wing_model(
         self,
         contract_type,
         observed_date,
         start_strike=None,
         end_strike=None,
         point_num=None,
         step=None,
         strike_type=FittingModelStrikeType.valueOf('STRIKE'),
         days_in_year=365,
         calendar_name=None):
     with self.make_session() as db_session:
         observed_date = DateTimeUtils.str2date(observed_date)
         if OptionStructureRepo.check_commodity(db_session, contract_type):
             vol_surface_dto = WingModelService.calc_commodity_vol_surface(
                 db_session, contract_type, observed_date, start_strike,
                 end_strike, point_num, step,
                 FittingModelStrikeType.valueOf(strike_type.upper()),
                 days_in_year, calendar_name)
         else:
             vol_surface_dto = WingModelService.calc_fund_vol_surface(
                 db_session, contract_type, observed_date, start_strike,
                 end_strike, point_num, step,
                 FittingModelStrikeType.valueOf(strike_type.upper()),
                 days_in_year, calendar_name)
         vol_surface_schema = VolSurfaceSchema()
         return vol_surface_schema.dump(vol_surface_dto).data
Ejemplo n.º 6
0
 async def get_instrument_rolling_vol(self,
                                      instrument_id,
                                      start_date,
                                      end_date,
                                      window,
                                      is_primary=False):
     with self.make_session() as db_session:
         start_date_obj = DateTimeUtils.str2date(start_date)
         end_date_obj = DateTimeUtils.str2date(end_date)
         realized_vol_dto_list, diagnostics = HistoricalVolService.calc_instrument_rolling_vol(
             db_session, instrument_id, start_date_obj, end_date_obj,
             window, is_primary)
     realized_vol_schema = RealizedVolSchema(
         many=True, exclude=['instrumentId', 'percentile'])
     return DiagnosticResponse(
         realized_vol_schema.dump(realized_vol_dto_list).data, diagnostics)
Ejemplo n.º 7
0
    def import_vol_surface_from_excel_file():
        """
        解析excel文件保存到 vol surface表
        :return:
        """
        instrument_ids = sys.argv[1].split(",")
        dir_case = sys.argv[3]
        valuation_date = DateTimeUtils.str2date(sys.argv[2])
        data = xlrd.open_workbook(dir_case)

        for instrument_id in instrument_ids:
            try:
                # 判断是否获取到了spot price
                instrument_dict = VolSurfaceExcelService.get_instrument_spot(
                    instrument_id)
                spot_price = instrument_dict.get('lastPrice')
                if spot_price is None:
                    logging.error('发送请求获取标的: %s的成功, 但是没有spot_price' %
                                  instrument_id)
                    continue
                logging.info('发送请求获取标的: %s的spot price成功' % instrument_id)
                logging.info('开始解析excel,标的为: %s' % instrument_id)
                table = data.sheet_by_name(instrument_id)
                vol_surface_dto = VolSurfaceExcelService.convert_to_vol_surface_dto(
                    instrument_id, valuation_date, table, spot_price)
                logging.info('解析excel成功,标的为: %s' % instrument_id)
                vol_surface_schema = VolSurfaceSchema()
                # 序列化对象
                vol_surface = vol_surface_schema.dump(vol_surface_dto).data
                # 发送请求
                VolSurfaceExcelService.send_post_request(vol_surface)
            except Exception as e:
                logging.error('标的: %s,出现错误: %s' % (instrument_id, e))
Ejemplo n.º 8
0
 async def get_instrument_id_list(self,
                                  trade_date=DateTimeUtils.date2str(
                                      date.today()),
                                  filtering=True):
     with self.make_session() as db_session:
         instrument_id_list = InstrumentService.\
             get_instrument_id_list(db_session, DateTimeUtils.str2date(trade_date), filtering)
     return instrument_id_list
Ejemplo n.º 9
0
 async def get_instrument_realized_vol(
         self,
         instrument_id,
         trade_date,
         windows=[1, 3, 5, 10, 22, 44, 66, 132],
         is_primary=False):
     with self.make_session() as db_session:
         trade_date_obj = DateTimeUtils.str2date(trade_date)
         if trade_date_obj > date.today():
             raise CustomException('所选日期不能超过今天')
         realized_vol_dto_list, diagnostics = HistoricalVolService.calc_instrument_realized_vol(
             db_session, instrument_id, DateTimeUtils.str2date(trade_date),
             windows, is_primary)
     realized_vol_schema = RealizedVolSchema(
         many=True, exclude=['tradeDate', 'instrumentId', 'percentile'])
     return DiagnosticResponse(
         realized_vol_schema.dump(realized_vol_dto_list).data, diagnostics)
    def get_future_contract_order(db_session, contract_type, exist_dates,
                                  start_date, end_date):
        holidays = TradingCalendarRepo.get_holiday_list(db_session)
        special_dates = []
        if start_date > end_date:
            logging.error(
                "日期指定非法:%s 大于 %s" % DateTimeUtils.date2str(start_date),
                DateTimeUtils.date2str(end_date))
            return None
        else:
            all_dates = [
                DateTimeUtils.str2date(date.strftime("%Y-%m-%d"))
                for date in rrule(DAILY, dtstart=start_date, until=end_date)
            ]
            if exist_dates:
                missing_dates = list(set(all_dates) - set(exist_dates))
            else:
                missing_dates = all_dates
            listed_date, delisted_date = DateTimeUtils.offset_trade_date(
                start_date, end_date, holidays, special_dates)
            close_dict = CommodityFutureContractService.get_corresponding_close(
                db_session, contract_type, listed_date, delisted_date)
            instruments_list = db_session.query(Instrument).filter(
                Instrument.contractType == contract_type)

            fc_list = []
            if close_dict:
                for trade_date in missing_dates:
                    if DateTimeUtils.is_trading_day(trade_date, holidays,
                                                    special_dates):
                        logging.info("处理交易日%s" %
                                     DateTimeUtils.date2str(trade_date))
                        previous_trade_date, _ = DateTimeUtils.offset_trade_date(
                            trade_date, trade_date, holidays, special_dates)
                        pri, sec = FutureContractInfoAlgo.calc_one_future_contract_info(
                            instruments_list, close_dict, contract_type,
                            previous_trade_date)
                        if pri:
                            fc_info = FutureContractInfo(
                                contractType=contract_type,
                                tradeDate=trade_date,
                                primaryContractId=pri,
                                secondaryContractId=sec)
                            logging.info(
                                '合约的主力和次主力为:%s %s %s %s' %
                                (fc_info.contractType,
                                 DateTimeUtils.date2str(fc_info.tradeDate),
                                 fc_info.primaryContractId,
                                 fc_info.secondaryContractId))
                            fc_list.append(fc_info)
                    else:
                        logging.info("跳过非交易日%s" %
                                     DateTimeUtils.date2str(trade_date))
            else:
                fc_list = None
            return fc_list
 async def get_implied_vol_report(self, instrument_id, report_date):
     with self.make_session() as db_session:
         report_date_obj = DateTimeUtils.str2date(report_date)
         if report_date_obj > date.today():
             raise CustomException('所选日期不能超过今天')
         vol_report_dto_list = OTCPositionSnapshotService.get_implied_vol_report(
             db_session, instrument_id, report_date_obj)
     implied_vol_report_schema = ImpliedVolReportSchema(many=True,
                                                        exclude=[])
     return implied_vol_report_schema.dump(vol_report_dto_list).data
Ejemplo n.º 12
0
 async def get_instrument_vol_cone(
         self,
         instrument_id,
         start_date,
         end_date,
         windows=[1, 3, 5, 10, 22, 44, 66, 132],
         percentiles=[0, 0.1, 0.25, 0.50, 0.75, 0.90, 1],
         is_primary=False):
     with self.make_session() as db_session:
         start_date_obj = DateTimeUtils.str2date(start_date)
         end_date_obj = DateTimeUtils.str2date(end_date)
         vol_cone_dto_list, diagnostics = HistoricalVolService.calc_instrument_vol_cone(
             db_session, instrument_id, start_date_obj, end_date_obj,
             windows, [percentile * 100 for percentile in percentiles],
             is_primary)
     vol_cone_schema = VolConeSchema(
         many=True,
         exclude=['vols.instrumentId', 'vols.tradeDate', 'vols.window'])
     return DiagnosticResponse(
         vol_cone_schema.dump(vol_cone_dto_list).data, diagnostics)
Ejemplo n.º 13
0
 def update_eod_date(start_date_str=EODDateConfig.eod_start_date,
                     end_date_str=DateTimeUtils.date2str(date.today()),
                     eod_cutoff_time=EODDateConfig.eod_cutoff_time):
     end_date = DateTimeUtils.str2date(end_date_str)
     start_date = DateTimeUtils.str2date(start_date_str)
     # 获取节假日信息
     db_session = create_db_session()
     # TODO: 需要从配置文件读取
     if not TradingDayService.is_trading_day(db_session, end_date):
         # 如果当天不是交易日则直接计算上一个交易日的值
         end_date = TradingDayService.go_trading_day(db_session, end_date, 1, -1)
     else:
         # 如果是交易日,小于cutoff time还是返回上一个交易日
         if datetime.now().time() < DateTimeUtils.str2time(eod_cutoff_time):
             end_date = TradingDayService.go_trading_day(db_session, end_date, 1, -1)
         else:
             end_date = end_date
     # 设置变量到airflow variable
     AirflowVariableUtils.set_eod_start_date(start_date)
     AirflowVariableUtils.set_eod_end_date(end_date)
Ejemplo n.º 14
0
 async def save_otc_atm_quote_list(self):
     # 如果标的物代码不为空,则忽略instrument_ids
     # TODO: 需要完善
     with self.make_session() as db_session:
         atm_quote_list = []
         dto = OtcAtmQuoteDTO()
         dto.uuid = 'f405e2f8-cb14-11e9-80de-00163e08c03e'
         dto.underlyer = 'RS911.CZC'
         dto.valuationDate = DateTimeUtils.str2date('2019-09-03')
         dto.askVol = 0.1
         dto.bidVol = 0.2
         atm_quote_list.append(dto)
         atm_quote_dto_list = OtcAtmQuoteService.save_otc_atm_quote_list(db_session, atm_quote_list)
     otc_atm_quote_schema = OtcAtmQuoteSchema(many=True, exclude=[])
     return otc_atm_quote_schema.dump(atm_quote_dto_list).data
Ejemplo n.º 15
0
 async def get_latest_vol_surface(
         self,
         instrument_id,
         valuation_date,
         strike_type=VolSurfaceStrikeType.PERCENT.name,
         instance=VolSurfaceInstanceType.CLOSE.name,
         is_primary=False):
     with self.make_session() as db_session:
         vol_surface_dto = ImpliedVolService.get_latest_vol_surface(
             db_session, instrument_id,
             DateTimeUtils.str2date(valuation_date), strike_type, instance,
             is_primary)
         if vol_surface_dto is None:
             raise CustomException('没有找到对应的波动率曲面')
     vol_surface_schema = VolSurfaceSchema(exclude=[])
     return vol_surface_schema.dump(vol_surface_dto).data
Ejemplo n.º 16
0
    def recon_one_instrument(self, params):
        instrument, start_date, end_date, holidays, dry_run, ignore_milestone = params
        db_session = std.create_db_session()
        try:
            logging.info("开始Recon标的物: %s" % instrument.instrumentId)
            # 获取标的物Milestone
            milestone = self.get_milestone(db_session, instrument)
            # 只处理标的物上市日期和退市日期之间的数据
            if instrument.listedDate is not None and start_date < instrument.listedDate:
                start_date = instrument.listedDate
            if instrument.delistedDate is not None and end_date > instrument.delistedDate:
                end_date = instrument.delistedDate
            # 需要Recon的日期由API给出
            quote_close_dates = self.request_quote_close_dates(instrument, start_date, end_date)
            if not quote_close_dates:
                unchecked_trading_dates = []
            else:
                unchecked_trading_dates = [DateTimeUtils.str2date(x) for x in quote_close_dates]
            # 对缺数数据进行处理
            existing_trading_dates = self.get_existing_trading_dates(db_session, instrument)
            # 计算出缺失数据
            missing_trading_dates = self.get_missing_trading_dates(instrument, unchecked_trading_dates,
                                                                   existing_trading_dates)
            if not dry_run:
                self.upsert_missing_trading_dates(db_session, instrument, missing_trading_dates)
            # TODO 需要对多余的数据进行处理
            # 计算出多余数据
            extra_trading_dates = []
            logging.info("Recon找到多余数据:%s -> %d 个Break" % (instrument.instrumentId, len(extra_trading_dates)))
            # 如果没有差值,则比较开始日期和Milestone,更新Milestone
            has_missing_dates = len(missing_trading_dates) != 0
            has_extra_dates = len(extra_trading_dates) != 0
            if (not has_missing_dates) and (not has_extra_dates) and (not dry_run):
                if start_date <= end_date:
                    self.upsert_milestone(db_session, instrument, start_date, end_date, milestone)
                else:
                    logging.info("标的物开始日期大于结束日期,不更新Milestone:%s [%s %s]" % (
                        instrument.instrumentId, start_date.strftime('%Y%m%d'), end_date.strftime('%Y%m%d')))

            return instrument, (not has_missing_dates) and (not has_extra_dates)
        except Exception as e:
            logging.error("Recon失败,标的物:%s, 异常:%s" % (instrument.instrumentId, e))
            return instrument, False
        finally:
            db_session.close()
Ejemplo n.º 17
0
    def get_holidays():

        ip = BCTServerConfig.host
        port = BCTServerConfig.port
        service = 'reference-data-service'
        method = 'refTradingCalendarGet'
        params = {'calendarId': 'DEFAULT_CALENDAR'}
        holidays = []
        try:
            result = call_request_from_bct(ip, port, service, method, params)
            if result == 'error':
                logging.error('发送请求获取trading calendar失败')
            else:
                holidays = result.get('result').get('holidays')
                holidays = [DateTimeUtils.str2date(_.get('holiday')) for _ in holidays]
        except Exception as e:
            logging.error('发送请求获取trading calendar失败')
        return holidays
Ejemplo n.º 18
0
 def get_eod_end_date():
     return DateTimeUtils.str2date(Variable.get(Constants.EOD_END_DATE))
Ejemplo n.º 19
0
 async def get_instrument_atm_vol_list(self, underlyder, start_date, end_date, is_primary=False):
     with self.make_session() as db_session:
         atm_vol_list, diagnostics = OtcAtmQuoteService.calc_instrument_atm_vol_list(
             db_session, underlyder, DateTimeUtils.str2date(start_date), DateTimeUtils.str2date(end_date), is_primary)
     realized_vol_schema = RealizedVolSchema(many=True, exclude=['instrumentId', 'window', 'percentile'])
     return DiagnosticResponse(realized_vol_schema.dump(atm_vol_list).data, diagnostics)
Ejemplo n.º 20
0
 def get_eod_manual_date():
     return DateTimeUtils.str2date(Variable.get(Constants.EOD_MANUAL_DATE))
Ejemplo n.º 21
0
 def get_eod_start_date():
     return DateTimeUtils.str2date(Variable.get(Constants.EOD_START_DATE))