def bizDatesList(holidayCenter, fromDate, toDate): cal = Calendar(holidayCenter) fromDate = Date.fromDateTime(fromDate) toDate = Date.fromDateTime(toDate) assert fromDate <= toDate, "from date ({0} must be earlier than to date {1}".format( fromDate, toDate) return [d.toDateTime() for d in cal.bizDatesList(fromDate, toDate)]
def testEvaluationDate(self): referenceDate = Date(2015, 1, 1) Settings.evaluationDate = referenceDate self.assertEqual(Settings.evaluationDate, referenceDate, "Evaluation Date should be \n" "expected: {0}\n" "calculated: {1}".format(referenceDate, Settings.evaluationDate)) # check wrong input with self.assertRaises(ValueError): Settings.evaluationDate = 2 # settings should be a singleton by default secondeSettings = SettingsFactory() self.assertEqual(Settings.evaluationDate, secondeSettings.evaluationDate, "Settings should be a singleton\n" "expected: {0}\n" "calculated: {1}" .format(Settings.evaluationDate, secondeSettings.evaluationDate)) # test forced building newSettings = SettingsFactory(forcedBuild=True) self.assertEqual(newSettings.evaluationDate, Date.todaysDate(), "Forced built settings should be a fresh object\n" "expected: {0}\n" "calculated: {1}".format(Date.todaysDate(), newSettings.evaluationDate))
def _filter_sec_on_tiaocang_date(self, tiaocang_date, sec_id): sse_cal = Calendar('China.SSE') tiaocang_date_prev = sse_cal.advanceDate( Date.strptime(str(tiaocang_date)[:10]), Period('-1b')).toDateTime() tiaocang_date_prev2 = sse_cal.advanceDate( Date.strptime(str(tiaocang_date)[:10]), Period('-2b')).toDateTime() price_data = get_sec_price(start_date=tiaocang_date_prev2, end_date=tiaocang_date, sec_ids=sec_id, data_source=self._data_source, csv_path=self._csv_path) price_data = price_data.transpose() price_data.index.name = 'secID' # 去除涨幅过大可能买不到的 price_data['returnFilter'] = price_data[tiaocang_date] / price_data[ tiaocang_date_prev] > 1 + self._filter_return_on_tiaocang_date # 去除有NaN的, 新股 price_data['ipoFilter'] = pd.isnull(price_data[tiaocang_date] * price_data[tiaocang_date_prev] * price_data[tiaocang_date_prev2]) # 去除停牌的,此处判断标准就是连续三天收盘价格一样 price_data['tingpaiFilter'] = ( (price_data[tiaocang_date] == price_data[tiaocang_date_prev]) & (price_data[tiaocang_date_prev] == price_data[tiaocang_date_prev2])) price_data['filters'] = 1 - (1 - price_data['returnFilter']) * ( 1 - price_data['ipoFilter']) * (1 - price_data['tingpaiFilter']) return price_data['filters']
def testParseDates(self): input_date = "2006-01-15" d = Date.strptime(input_date, "%Y-%m-%d") flag = d == Date(2006, 1, 15) self.assertTrue(flag, "date parsing failed\n" " input date: {0:s}\n" " parsed: {1}".format(input_date, d)) input_date = "12/02/2012" d = Date.strptime(input_date, "%m/%d/%Y") flag = d == Date(2012, 12, 2) self.assertTrue(flag, "date parsing failed\n" " input date: {0:s}\n" " parsed: {1}".format(input_date, d)) d = Date.strptime(input_date, "%d/%m/%Y") flag = d == Date(2012, 2, 12) self.assertTrue(flag, "date parsing failed\n" " input date: {0:s}\n" " parsed: {1}".format(input_date, d)) input_date = "20011002" d = Date.strptime(input_date, "%Y%m%d") flag = d == Date(2001, 10, 2) self.assertTrue(flag, "date parsing failed\n" " input date: {0:s}\n" " parsed: {1}".format(input_date, d))
def testEvaluationDate(self): referenceDate = Date(2015, 1, 1) Settings.evaluationDate = referenceDate self.assertEqual( Settings.evaluationDate, referenceDate, "Evaluation Date should be \n" "expected: {0}\n" "calculated: {1}".format(referenceDate, Settings.evaluationDate)) # check wrong input with self.assertRaises(ValueError): Settings.evaluationDate = 2 # settings should be a singleton by default secondeSettings = SettingsFactory() self.assertEqual( Settings.evaluationDate, secondeSettings.evaluationDate, "Settings should be a singleton\n" "expected: {0}\n" "calculated: {1}".format(Settings.evaluationDate, secondeSettings.evaluationDate)) # test forced building newSettings = SettingsFactory(forcedBuild=True) self.assertEqual( newSettings.evaluationDate, Date.todaysDate(), "Forced built settings should be a fresh object\n" "expected: {0}\n" "calculated: {1}".format(Date.todaysDate(), newSettings.evaluationDate))
def testDateAdvanceOutOfBounds(self): testDate = Date(2199, 12, 30) with self.assertRaises(ValueError): _ = testDate + '1w' testDate = Date(1901, 1, 1) with self.assertRaises(ValueError): _ = testDate - '1w'
def datesList(fromDate, toDate): fromDate = Date.fromDateTime(fromDate) toDate = Date.fromDateTime(toDate) assert fromDate <= toDate, "from date ({0} must be earlier than to date {1}".format( fromDate, toDate) return [ Date.fromExcelSerialNumber(serial).toDateTime() for serial in range(fromDate.serialNumber, toDate.serialNumber + 1) ]
def testScheduleInitializeWithYearly(self): startDate = Date(2012, 2, 29) endDate = Date(2013, 3, 1) tenor = Period('1y') cal = Calendar('NullCalendar') sch = Schedule(startDate, endDate, tenor, cal) expected = [Date(2012, 2, 29), Date(2013, 2, 28), Date(2013, 3, 1)] for i in range(sch.size()): self.assertEqual(expected[i], sch[i])
def testScheduleDeepCopy(self): startDate = Date(2013, 3, 31) endDate = Date(2013, 6, 30) tenor = Period('1m') cal = Calendar('NullCalendar') sch = Schedule(startDate, endDate, tenor, cal) copied_sch = copy.deepcopy(sch) self.assertEqual(sch, copied_sch)
def testParseDates(self): input_date = "2006-01-15" d = Date.strptime(input_date, "%Y-%m-%d") flag = d == Date(2006, 1, 15) self.assertTrue( flag, "date parsing failed\n" " input date: {0:s}\n" " parsed: {1}".format(input_date, d)) input_date = "12/02/2012" d = Date.strptime(input_date, "%m/%d/%Y") flag = d == Date(2012, 12, 2) self.assertTrue( flag, "date parsing failed\n" " input date: {0:s}\n" " parsed: {1}".format(input_date, d)) d = Date.strptime(input_date, "%d/%m/%Y") flag = d == Date(2012, 2, 12) self.assertTrue( flag, "date parsing failed\n" " input date: {0:s}\n" " parsed: {1}".format(input_date, d)) input_date = "20011002" d = Date.strptime(input_date, "%Y%m%d") flag = d == Date(2001, 10, 2) self.assertTrue( flag, "date parsing failed\n" " input date: {0:s}\n" " parsed: {1}".format(input_date, d))
def testAdvanceDate(self): referenceDate = Date(2014, 1, 31) sseCal = Calendar('China.SSE') ibCal = Calendar('China.IB') bizDayConv = BizDayConventions.Following # test null period self.assertEqual(sseCal.advanceDate(referenceDate, '0b', bizDayConv), Date(2014, 2, 7)) # test negative period self.assertEqual(sseCal.advanceDate(referenceDate, '-5b', bizDayConv), Date(2014, 1, 24)) # The difference is caused by Feb 8 is SSE holiday but a working day for IB market self.assertEqual(sseCal.advanceDate(referenceDate, '2b', bizDayConv), Date(2014, 2, 10)) self.assertEqual(sseCal.advanceDate(referenceDate, '2d', bizDayConv), Date(2014, 2, 7)) self.assertEqual(ibCal.advanceDate(referenceDate, '2b', bizDayConv), Date(2014, 2, 8)) self.assertEqual(ibCal.advanceDate(referenceDate, '2d', bizDayConv), Date(2014, 2, 7)) bizDayConv = BizDayConventions.ModifiedFollowing # May 31, 2014 is a holiday self.assertEqual( sseCal.advanceDate(referenceDate, '4m', bizDayConv, True), Date(2014, 5, 30))
def advanceDateByCalendar(holidayCenter, referenceDate, period, convention=BizDayConventions.Following): cal = Calendar(holidayCenter) refer = Date.fromDateTime(referenceDate) return cal.advanceDate(refer, period, convention).toDateTime()
def calc_alpha_factor_weight_on_date(self, date): """ :param date: datetime, 调仓日 :return: pd.DataFrame, index = [layerFactor], cols= [alpha factor name] 给定调仓日,计算alpha因子的加权矩阵 """ if isinstance(date, basestring): date = Date.strptime(date).toDateTime() ret_low = pd.DataFrame(columns=self._alphaFactorNames) ret_high = pd.DataFrame(columns=self._alphaFactorNames) tiao_cang_date_range = self._tiaoCangDate[ self._tiaoCangDate.index(date) - self._tiaoCangDateWindowSize:self._tiaoCangDate.index(date)] for layerFactor in self._layerFactor: if self._factorWeightType == FactorWeightType.EqualWeight: ret_low.loc[layerFactor.name] = self._alphaFactorSign ret_high.loc[layerFactor.name] = self._alphaFactorSign else: if self._rank_ic is None: self._rank_ic = self.calc_rank_ic() low, high = self._rank_ic[0][ layerFactor.name], self._rank_ic[1][layerFactor.name] low_to_use = low.loc[tiao_cang_date_range] high_to_use = high.loc[tiao_cang_date_range] weight_low = low_to_use.mean(axis=0) / low_to_use.std(axis=0) weight_high = high_to_use.mean(axis=0) / high_to_use.std( axis=0) ret_low.loc[layerFactor.name] = weight_low.values ret_high.loc[layerFactor.name] = weight_high.values return ret_low, ret_high
def testSchedulePickle(self): startDate = Date(2013, 3, 31) endDate = Date(2013, 6, 30) tenor = Period('1m') cal = Calendar('NullCalendar') sch = Schedule(startDate, endDate, tenor, cal) f = tempfile.NamedTemporaryFile('w+b', delete=False) pickle.dump(sch, f) f.close() with open(f.name, 'rb') as f2: pickled_sch = pickle.load(f2) self.assertEqual(sch, pickled_sch) os.unlink(f.name)
def datesList(fromDate, toDate): fromDate = check_date(fromDate) toDate = check_date(toDate) return [ Date.fromExcelSerialNumber(serial).toDateTime() for serial in range(fromDate.serialNumber, toDate.serialNumber + 1) ]
def date_stamps(start_date, end_date): start_date = Date.fromDateTime(start_date) end_date = Date.fromDateTime(end_date) start_year = start_date.year() start_month = start_date.month() if start_month <= 3: start_month = 3 elif start_month <= 6: start_month = 6 elif start_month <= 9: start_month = 9 else: start_month = 12 stamps = [] start_point = Date(start_year, start_month, 1) start_point = Date.endOfMonth(start_point) while start_point <= end_date: stamps.append(start_point.toDateTime().strftime('%Y%m%d')) start_point = Date.endOfMonth(start_point + '3m') return stamps
def testAdjustDate(self): # April 30, 2005 is a working day under IB, but a holiday under SSE referenceDate = Date(2005, Months.April, 30) sseCal = Calendar('China.SSE') ibCal = Calendar('China.IB') bizDayConv = BizDayConventions.Unadjusted self.assertEqual(sseCal.adjustDate(referenceDate, bizDayConv), referenceDate) self.assertEqual(ibCal.adjustDate(referenceDate, bizDayConv), referenceDate) bizDayConv = BizDayConventions.Following self.assertEqual(sseCal.adjustDate(referenceDate, bizDayConv), Date(2005, Months.May, 9)) self.assertEqual(ibCal.adjustDate(referenceDate, bizDayConv), Date(2005, Months.April, 30)) bizDayConv = BizDayConventions.ModifiedFollowing self.assertEqual(sseCal.adjustDate(referenceDate, bizDayConv), Date(2005, Months.April, 29)) self.assertEqual(ibCal.adjustDate(referenceDate, bizDayConv), Date(2005, Months.April, 30))
def testNullCalendar(self): cal = Calendar("Null") testDate = Date(2015, 1, 1) self.assertTrue(cal.isBizDay(testDate)) self.assertTrue(not cal.isHoliday(testDate)) self.assertTrue(cal.isWeekEnd(Weekdays.Saturday)) self.assertTrue(cal.isWeekEnd(Weekdays.Sunday)) self.assertTrue(not cal.isWeekEnd(Weekdays.Friday))
def calc_alpha_factor_rank_on_date(self, date, factor_low_weight, factor_high_weight): """ :param date, str/datetime, tiaoCangDate :param factor_low_weight, pd.DataFrame, see calc_alpha_factor_weight_on_date :param factor_high_weight, pd.DataFrame, :return: pd.DataFrame, index = [layerFactor, secID, low/high], index = layerfactor, col = alpha factor 给定调仓日,计算secIDs的alpha因子的排位 """ ret = pd.DataFrame() if isinstance(date, basestring): date = Date.strptime(date).toDateTime() for layerFactor in self._layerFactor: # 分层因子下股票分为两组 group_low, group_high = DCAMHelper.seperate_sec_group( layerFactor, date) factor_low = DCAMHelper.get_factor_on_date(self._alphaFactor, group_low, date) factor_high = DCAMHelper.get_factor_on_date( self._alphaFactor, group_high, date) # 排序的顺序由权重决定 # 如果权重为正,那么从低到高排序 # 如果权重为负,那么从高到底排序 # 加权的时候权重使用绝对值 factor_low_rank = pd.DataFrame() factor_high_rank = pd.DataFrame() for alphaFactorName in self._alphaFactorNames: flag_low = True if factor_low_weight[alphaFactorName][ layerFactor.name] >= 0 else False flag_high = True if factor_high_weight[alphaFactorName][ layerFactor.name] >= 0 else False factor_low_rank_col = factor_low[alphaFactorName].rank( ascending=flag_low, axis=0) factor_high_rank_col = factor_high[alphaFactorName].rank( ascending=flag_high, axis=0) factor_low_rank = pd.concat( [factor_low_rank, factor_low_rank_col], axis=1) factor_high_rank = pd.concat( [factor_high_rank, factor_high_rank_col], axis=1) # multi index DataFrame sec_id_index = np.append(factor_low_rank.index, factor_high_rank.index) layer_factor_index = [layerFactor.name] * len(sec_id_index) high_low_index = ['low'] * len(factor_low_rank) + ['high'] * len( factor_high_rank) factor_rank_array = pd.concat([factor_low_rank, factor_high_rank], axis=0).values index = pd.MultiIndex.from_arrays( [sec_id_index, layer_factor_index, high_low_index], names=['secID', 'layerFactor', 'low_high']) alpha_factor_rank = pd.DataFrame(factor_rank_array, index=index, columns=self._alphaFactorNames) # merge ret = pd.concat([ret, alpha_factor_rank], axis=0) ret = factor_na_handler(ret, self._na_handler) return ret
def get_pos_adj_date(start_date, end_date, formats="%Y-%m-%d", calendar='China.SSE', freq='m'): """ :param start_date: str/datetime.datetime, start date of strategy :param end_date: str/datetime.datetime, end date of strat egy :param formats: optional, formats of the string date :param calendar: str, optional, name of the calendar to use in dates math :param freq: str, optional, the frequency of data :return: list of datetime.datetime, pos adjust dates """ if isinstance(start_date, str) and isinstance(end_date, str): d_start_date = Date.strptime(start_date, formats) d_end_date = Date.strptime(end_date, formats) elif isinstance(start_date, datetime.datetime) and isinstance( end_date, datetime.datetime): d_start_date = Date.fromDateTime(start_date) d_end_date = Date.fromDateTime(end_date) cal = Calendar(calendar) pos_adjust_date = Schedule(d_start_date, d_end_date, Period(length=1, units=_freqDict[freq]), cal, BizDayConventions.Unadjusted) # it fails if setting dStartDate to be first adjustment date, then use Schedule to compute the others # so i first compute dates list in each period, then compute the last date of each period # last day of that period(month) is the pos adjustment date if _freqDict[freq] == TimeUnits.Weeks: pos_adjust_date = [ Date.toDateTime(Date.nextWeekday(date, Weekdays.Friday)) for date in pos_adjust_date[:-1] ] elif _freqDict[freq] == TimeUnits.Months: pos_adjust_date = [ Date.toDateTime(cal.endOfMonth(date)) for date in pos_adjust_date[:-1] ] elif _freqDict[freq] == TimeUnits.Years: pos_adjust_date = [ Date.toDateTime(Date(date.year(), 12, 31)) for date in pos_adjust_date[:-1] ] pos_adjust_date = [ date for date in pos_adjust_date if date <= d_end_date.toDateTime() ] return pos_adjust_date
def testEvaluationDate(self): referenceDate = Date(2015, 1, 1) Settings.evaluationDate = referenceDate self.assertEqual(Settings.evaluationDate, referenceDate, "Evaluation Date should be \n" "expected: {0}\n" "calculated: {1}".format(referenceDate, Settings.evaluationDate)) # check wrong input with self.assertRaises(ValueError): Settings.evaluationDate = 2
def testChinaIB(self): # China Inter Bank working weekend list in the year 2014 expectedWorkingWeekEnd = [Date(2014, 1, 26), Date(2014, 2, 8), Date(2014, 5, 4), Date(2014, 9, 28), Date(2014, 10, 11), # China Inter Bank working weekend list in the year 2015 Date(2015, 1, 4), Date(2015, 2, 15), Date(2015, 2, 28), Date(2015, 9, 6), Date(2015, 10, 10)] cal = Calendar('China.IB') for day in expectedWorkingWeekEnd: self.assertEqual(cal.isHoliday(day), False, "{0} is not expected to be a holiday in {1}".format(day, cal)) self.assertEqual(cal.isBizDay(day), True, "{0} is expected to be a working day in {1} ".format(day, cal))
def forward_date(date, tenor, date_format='%Y-%m-%d'): try: # use pyfin instead to get more accurate and flexible date math start_date = Date.strptime(date, date_format) sseCal = Calendar('China.SSE') ret = sseCal.advanceDate(start_date, Period('-' + tenor), endOfMonth=True) # 此处返回的是上一期期末日期,再向后调整一天,以避免区间日期重叠 ret = sseCal.advanceDate(ret, Period('1b')) return str(ret) except NameError: pass
def map_to_biz_day(date_series, calendar='China.SSE', convention=BizDayConventions.Preceding): """ :param date_series: pd.Sereis, datetime.datetime :param calendar: str, optional, name of the calendar to use in dates math :param convention: str, optional, pyFin date conventions :return: pd.Series, datetime.datetime 用更快的方式计算, 避免对每个日期进行循环 """ unique_date_list = sorted(set(date_series)) py_date_list = [Date.fromDateTime(date) for date in unique_date_list] py_date_list = [ Calendar(calendar).adjustDate(date, convention) for date in py_date_list ] biz_day_list = [Date.toDateTime(date) for date in py_date_list] dict_date_map = dict(zip(unique_date_list, biz_day_list)) ret = date_series.map(dict_date_map) return ret
def testIsoDate(self): input_date = "2006-01-15" d = Date.parseISO(input_date) flag = d.dayOfMonth() == 15 and \ d.month() == 1 and \ d.year() == 2006 self.assertTrue(flag, "Iso date failed\n" " input date: {0}\n" " day of month: {1:d}\n" " month: {2:d}\n" " year: {3:d}".format(input_date, d.dayOfMonth(), d.month(), d.year()))
def testDatePickle(self): benchmark_date = Date(2016, 1, 2) f = tempfile.NamedTemporaryFile('w+b', delete=False) pickle.dump(benchmark_date, f) f.close() with open(f.name, 'rb') as f2: pickled_date = pickle.load(f2) self.assertEqual(benchmark_date, pickled_date) os.unlink(f.name)
def _filter_sec_on_tiaocang_date(self, tiaocang_date, sec_id): sse_cal = Calendar('China.SSE') tiaocang_date_prev = sse_cal.advanceDate(Date.strptime(str(tiaocang_date)[:10]), '-1b').toDateTime() tiaocang_date_prev2 = sse_cal.advanceDate(Date.strptime(str(tiaocang_date)[:10]), '-2b').toDateTime() price_data = WindMarketDataHandler.get_sec_price_on_date(start_date=tiaocang_date_prev2, end_date=tiaocang_date, sec_ids=sec_id) price_data = price_data.transpose() price_data.index.name = 'sec_id' # 去除涨幅过大可能买不到的 price_data['returnFilter'] = price_data[tiaocang_date] / price_data[ tiaocang_date_prev] > 1 + self._filterReturnOnTiaoCangDate # 去除有NaN的, 新股 price_data['ipoFilter'] = pd.isnull( price_data[tiaocang_date] * price_data[tiaocang_date_prev] * price_data[tiaocang_date_prev2]) # 去除停牌的,此处判断标准就是连续三天收盘价格一样 price_data['tingpaiFilter'] = ((price_data[tiaocang_date] == price_data[tiaocang_date_prev]) & ( price_data[tiaocang_date_prev] == price_data[tiaocang_date_prev2])) price_data['filters'] = 1 - (1 - price_data['returnFilter']) * (1 - price_data['ipoFilter']) * ( 1 - price_data['tingpaiFilter']) return price_data['filters']
def get_report_date(act_date, return_biz_day=True): """ :param act_date: str/datetime.datetime, 任意日期 :param return_biz_day: bool, 是否返回交易日 :return: datetime, 对应应使用的报告日期, 从wind数据库中爬取 此函数的目的是要找到,任意时刻可使用最新的季报数据的日期,比如2-20日可使用的最新季报是去年的三季报(对应日期为9-30), """ if isinstance(act_date, str): act_date = Date.strptime(act_date) elif isinstance(act_date, datetime.datetime): act_date = Date.fromDateTime(act_date) act_month = act_date.month() act_year = act_date.year() if 1 <= act_month <= 3: # 第一季度使用去年三季报的数据 year = act_year - 1 month = 9 day = 30 elif 4 <= act_month <= 7: # 第二季度使用当年一季报 year = act_year month = 3 day = 31 elif 8 <= act_month <= 9: # 第三季度使用当年中报 year = act_year month = 6 day = 30 else: year = act_year # 第四季度使用当年三季报 month = 9 day = 30 if return_biz_day: date_adj = Calendar('China.SSE').adjustDate( Date(year, month, day), BizDayConventions.Preceding) ret = date_adj.toDateTime() else: ret = datetime.datetime(year, month, day) return ret
def testIsoDate(self): input_date = "2006-01-15" d = Date.parseISO(input_date) flag = d.dayOfMonth() == 15 and \ d.month() == 1 and \ d.year() == 2006 self.assertTrue( flag, "Iso date failed\n" " input date: {0}\n" " day of month: {1:d}\n" " month: {2:d}\n" " year: {3:d}".format(input_date, d.dayOfMonth(), d.month(), d.year()))
def __init__(self, layer_factor, alpha_factor, sec_return, tiaocang_date, tiaocang_date_window_size=12, save_sec_score=True, factor_weight_type=FactorWeightType.ICWeight, alpha_factor_sign=None, na_handler=FactorNAHandler.ReplaceWithMedian): self._layerFactor = layer_factor self._layerFactorNames = [ layer_factor.name for layer_factor in self._layerFactor ] self._alphaFactor = alpha_factor self._alphaFactorNames = [ alpha_factor.name for alpha_factor in self._alphaFactor ] self._secReturn = sec_return self._tiaoCangDate = tiaocang_date self._startDate = str(Date.fromDateTime(self._tiaoCangDate[0])) self._endDate = str(Date.fromDateTime(self._tiaoCangDate[-1])) self._tiaoCangDateWindowSize = tiaocang_date_window_size pyFinAssert( len(self._tiaoCangDate) > self._tiaoCangDateWindowSize, ValueError, "length of tiaoCangDate must be larger than moving window size") self._saveSecScore = save_sec_score self._factorWeightType = factor_weight_type self._alphaFactorSign = alpha_factor_sign self._na_handler = na_handler self._rank_ic = None if self._factorWeightType == FactorWeightType.EqualWeight: pyFinAssert( len(self._alphaFactorSign) == len(self._alphaFactor), ValueError, "length of alpha_factor_sign({0}), does not equal to that of alpha factor({1})" .format(len(self._alphaFactorSign), len(self._alphaFactor)))
def testCalendarWithDayConvention(self): sseCal = Calendar('China.SSE') referenceDate = Date(2015, 2, 14) testDate = sseCal.adjustDate(referenceDate, BizDayConventions.HalfMonthModifiedFollowing) self.assertEqual(testDate, Date(2015, 2, 13)) referenceDate = Date(2014, 2, 4) testDate = sseCal.adjustDate(referenceDate, BizDayConventions.ModifiedPreceding) self.assertEqual(testDate, Date(2014, 2, 7)) referenceDate = Date(2014, 2, 3) testDate = sseCal.adjustDate(referenceDate, BizDayConventions.Nearest) self.assertEqual(testDate, Date(2014, 2, 7)) referenceDate = Date(2014, 2, 2) testDate = sseCal.adjustDate(referenceDate, BizDayConventions.Nearest) self.assertEqual(testDate, Date(2014, 1, 30)) with self.assertRaises(ValueError): _ = sseCal.adjustDate(referenceDate, -1)
def testScheduleInitialize(self): startDate = Date(2013, 3, 31) endDate = Date(2013, 6, 30) tenor = Period('1m') cal = Calendar('NullCalendar') sch = Schedule(startDate, endDate, tenor, cal) expected = [ Date(2013, 3, 31), Date(2013, 4, 30), Date(2013, 5, 31), Date(2013, 6, 30) ] for i in range(sch.size()): self.assertEqual(expected[i], sch[i])
def testBasicFunctions(self): testDate = Date(2015, 7, 11) cal = Calendar('China.SSE') self.assertTrue(cal.isWeekEnd(testDate.weekday()), "{0} is expected to be a weekend".format(testDate)) testDate = Date(2015, 7, 13) self.assertTrue(not cal.isWeekEnd(testDate.weekday()), "{0} is expected not to be a weekend".format(testDate)) testDate = Date(2015, 5, 29) cal = Calendar('China.SSE') self.assertTrue(cal.isEndOfMonth(testDate), "{0} is expected to be a end of month".format(testDate)) testDate = Date(2015, 5, 1) cal = Calendar('China.SSE') endOfMonth = cal.endOfMonth(testDate) self.assertEqual(endOfMonth, Date(2015, 5, 29), "The month end of 2015/5 is expected to be {0}".format(Date(2015, 5, 29))) bizDates1 = cal.bizDaysBetween(Date(2015, 1, 1), Date(2015, 12, 31), True, False) bizDates2 = cal.bizDaysBetween(Date(2015, 12, 31), Date(2015, 1, 1), False, True) self.assertEqual(bizDates1, bizDates2)
def nthWeekDay(nth, dayOfWeek, month, year): date = Date.nthWeekday(nth, dayOfWeek, month, year) return date.toDateTime()
def testConsistency(self): minDate = Date.minDate().serialNumber + 1 maxDate = Date.maxDate().serialNumber dyold = Date.fromExcelSerialNumber(minDate - 1).dayOfYear() dold = Date.fromExcelSerialNumber(minDate - 1).dayOfMonth() mold = Date.fromExcelSerialNumber(minDate - 1).month() yold = Date.fromExcelSerialNumber(minDate - 1).year() wdold = Date.fromExcelSerialNumber(minDate - 1).weekday() for i in range(minDate, maxDate + 1): t = Date.fromExcelSerialNumber(i) serial = t.serialNumber self.assertEqual(serial, i, "inconsistent serial number:\n" " original: {0:d}\n" " serial number: {1:d}".format(i, serial)) dy = t.dayOfYear() d = t.dayOfMonth() m = t.month() y = t.year() wd = t.weekday() flag = (dy == dyold + 1) or \ (dy == 1 and dyold == 365 and not Date.isLeap(yold)) or \ (dy == 1 and dyold == 366 and Date.isLeap(yold)) self.assertTrue(flag, "wrong day of year increment: \n" " date: {0}\n" " day of year: {1:d}\n" " previous: {2:d}".format(t, dy, dyold)) dyold = dy flag = (d == dold + 1 and m == mold and y == yold) or \ (d == 1 and m == mold + 1 and y == yold) or \ (d == 1 and m == 1 and y == yold + 1) self.assertTrue(flag, "wrong day,month,year increment: \n" " date: {0}\n" " year,month,day: {1:d}, {2:d}, {3:d}\n" " previous: {4:d}, {5:d}, {6:d}".format(t, y, m, d, yold, mold, dold)) dold = d mold = m yold = y self.assertTrue(d >= 1, "invalid day of month: \n" " date: {0}\n" " day: {1:d}".format(t, d)) flag = (m == 1 and d <= 31) or \ (m == 2 and d <= 28) or \ (m == 2 and d == 29 and Date.isLeap(y)) or \ (m == 3 and d <= 31) or \ (m == 4 and d <= 30) or \ (m == 5 and d <= 31) or \ (m == 6 and d <= 30) or \ (m == 7 and d <= 31) or \ (m == 8 and d <= 31) or \ (m == 9 and d <= 30) or \ (m == 10 and d <= 31) or \ (m == 11 and d <= 30) or \ (m == 12 and d <= 31) self.assertTrue(flag, "invalid day of month: \n" " date: {0}\n" " day: {1:d}".format(t, d)) flag = (wd == (wdold + 1)) or (wd == 1 or wdold == 7) self.assertTrue(flag, "invalid weekday: \n" " date: {0}\n" " weekday: {1:d}\n" " previous: {2:d}".format(t, wd, wdold)) wdold = wd s = Date(y, m, d) serial = s.serialNumber self.assertTrue(serial == i, "inconsistent serial number:\n" " date: {0}\n" " serial number: {1:d}\n" " cloned date: {2}\n" " serial number: {3:d}".format(t, i, s, serial))
def testBasicFunctions(self): year = 2015 month = 7 day = 24 strRepr = "{0}-{1:02d}-{2:02d}".format(year, month, day) innerRepr = "Date({0}, {1}, {2})".format(year, month, day) testDate = Date(year, month, day) self.assertEqual(str(testDate), strRepr, "date string:\n" "expected: {0:s}\n" "calculated: {1:s}".format(strRepr, str(testDate))) self.assertEqual(repr(testDate), innerRepr, "date representation:\n" "expected: {0:s}\n" "calculated: {1:s}".format(innerRepr, repr(testDate))) self.assertEqual(testDate.year(), year, "date year:\n" "expected: {0:d}\n" "calculated: {1:d}".format(year, testDate.year())) self.assertEqual(testDate.month(), month, "date month:\n" "expected: {0:d}\n" "calculated: {1:d}".format(month, testDate.month())) self.assertEqual(testDate.dayOfMonth(), day, "date day:\n" "expected: {0:d}\n" "calculated: {1:d}".format(day, testDate.dayOfMonth())) self.assertEqual(testDate.dayOfYear(), testDate - Date(2015, 1, 1) + 1, "date day:\n" "expected: {0:d}\n" "calculated: {1:d}" .format(testDate - Date(2015, 1, 1) + 1, testDate.dayOfYear())) self.assertEqual(testDate.weekday(), 6, "date weekday:\n" "expected: {0:d}\n" "calculated: {1:d}".format(5, testDate.weekday())) self.assertEqual(testDate.toDateTime(), dt.date(year, month, day), "date datetime representation\n" "expected: {0}\n" "calculated: {1}".format( dt.datetime(year, month, day), testDate.toDateTime())) serialNumber = testDate.serialNumber serialDate = Date(serialNumber=serialNumber) self.assertEqual(serialDate, testDate, "date excel serial number representation\n" "expected: {0:d}" "calculated: {1:d}".format(serialDate.serialNumber, testDate.serialNumber)) # test comparisons previousDate = testDate - 1 self.assertTrue(previousDate < testDate, "{0} is not earlier than {1}".format(previousDate, testDate)) self.assertFalse(previousDate >= testDate, "{0} should not be later than or equal to {1}".format(previousDate, testDate)) self.assertTrue((previousDate + 1) == testDate, "{0} plus one day should be equal to {1}".format(previousDate, testDate)) # check static members self.assertEqual(Date.minDate(), Date(1901, 1, 1), "min date is wrong") self.assertEqual(Date.maxDate(), Date(2199, 12, 31), "max date is wrong") self.assertEqual(Date.endOfMonth(testDate), Date(year, month, 31), "end of month is wrong") self.assertTrue(Date.isEndOfMonth(Date(year, month, 31)), "{0} should be the end of month") self.assertEqual(Date.nextWeekday(testDate, testDate.weekday()), testDate, "{0}'s next same week day should be {1}" .format(testDate, testDate)) self.assertEqual(Date.todaysDate().toDateTime(), dt.date.today(), "today's date\n" "expected: {0}\n" "calculated: {1}".format(dt.date.today(), Date.todaysDate())) # nth-week day with self.assertRaises(ValueError): _ = Date.nthWeekday(0, Weekdays.Friday, 1, 2015) with self.assertRaises(ValueError): _ = Date.nthWeekday(6, Weekdays.Friday, 1, 2015) self.assertEqual(Date.nthWeekday(3, Weekdays.Wednesday, 8, 2015), Date(2015, 8, 19)) # check plus/sub threeWeeksAfter = testDate + '3W' expectedDate = testDate + 21 self.assertEqual(threeWeeksAfter, expectedDate, "date + 3w period\n" "expected: {0}\n" "calculated: {1}".format(expectedDate, threeWeeksAfter)) threeMonthsBefore = testDate - "3M" expectedDate = Date(year, month - 3, day) self.assertEqual(threeMonthsBefore, expectedDate, "date - 3m period\n" "expected: {0}\n" "calculated: {1}".format(expectedDate, threeMonthsBefore)) threeMonthsBefore = testDate - Period("3M") expectedDate = Date(year, month - 3, day) self.assertEqual(threeMonthsBefore, expectedDate, "date - 3m period\n" "expected: {0}\n" "calculated: {1}".format(expectedDate, threeMonthsBefore)) threeMonthsAfter = testDate + "3m" expectedDate = Date(year, month + 3, day) self.assertEqual(threeMonthsAfter, expectedDate, "date + 3m period\n" "expected: {0}\n" "calculated: {1}".format(expectedDate, threeMonthsAfter)) oneYearAndTwoMonthsBefore = testDate - "14m" expectedDate = Date(year - 1, month - 2, day) self.assertEqual(oneYearAndTwoMonthsBefore, expectedDate, "date - 14m period\n" "expected: {0}\n" "calculated: {1}".format(expectedDate, threeMonthsBefore)) oneYearAndTwoMonthsBefore = testDate + "14m" expectedDate = Date(year + 1, month + 2, day) self.assertEqual(oneYearAndTwoMonthsBefore, expectedDate, "date + 14m period\n" "expected: {0}\n" "calculated: {1}".format(expectedDate, threeMonthsBefore)) fiveMonthsAfter = testDate + "5m" expectedDate = Date(year, month + 5, day) self.assertEqual(fiveMonthsAfter, expectedDate, "date + 5m period\n" "expected: {0}\n" "calculated: {1}".format(expectedDate, fiveMonthsAfter))
def datesList(fromDate, toDate): fromDate = check_date(fromDate) toDate = check_date(toDate) assert fromDate <= toDate, "from date ({0} must be earlier than to date {1}".format(fromDate, toDate) return [Date.fromExcelSerialNumber(serial).toDateTime() for serial in range(fromDate.serialNumber, toDate.serialNumber + 1)]
def __init__(self, effectiveDate, terminationDate, tenor, calendar, convention=BizDayConventions.Following, terminationConvention=BizDayConventions.Following, dateGenerationRule=DateGeneration.Forward, endOfMonth=False, firstDate=None, nextToLastDate=None): # Initialize private data self._tenor = tenor self._cal = calendar self._convention = convention self._terminationConvention = terminationConvention self._rule = dateGenerationRule self._dates = [] self._isRegular = [] if tenor < Period("1M"): self._endOfMonth = False else: self._endOfMonth = endOfMonth if firstDate is None or firstDate == effectiveDate: self._firstDate = None else: self._firstDate = firstDate if nextToLastDate is None or nextToLastDate == terminationDate: self._nextToLastDate = None else: self._nextToLastDate = nextToLastDate # in many cases (e.g. non-expired bonds) the effective date is not # really necessary. In these cases a decent placeholder is enough if effectiveDate is None and firstDate is None and dateGenerationRule == DateGeneration.Backward: evalDate = Settings.evaluationDate pyFinAssert(evalDate < terminationDate, ValueError, "null effective date") if nextToLastDate is not None: y = int((nextToLastDate - evalDate) / 366) + 1 effectiveDate = nextToLastDate - Period(y, TimeUnits.Years) else: y = int((terminationDate - evalDate) / 366) + 1 effectiveDate = terminationDate - Period(y, TimeUnits.Years) else: pyFinAssert(effectiveDate is not None, ValueError, "null effective date") pyFinAssert(effectiveDate < terminationDate, ValueError, "effective date ({0}) " "later than or equal to termination date ({1}" .format(effectiveDate, terminationDate)) if tenor.length == 0: self._rule = DateGeneration.Zero else: pyFinAssert(tenor.length > 0, ValueError, "non positive tenor ({0:d}) not allowed".format(tenor.length)) if self._firstDate is not None: if self._rule == DateGeneration.Backward or self._rule == DateGeneration.Forward: pyFinAssert(effectiveDate < self._firstDate < terminationDate, ValueError, "first date ({0}) out of effective-termination date range [{1}, {2})" .format(self._firstDate, effectiveDate, terminationDate)) # we should ensure that the above condition is still # verified after adjustment elif self._rule == DateGeneration.Zero: raise ValueError("first date incompatible with {0:d} date generation rule".format(self._rule)) else: raise ValueError("unknown rule ({0:d})".format(self._rule)) if self._nextToLastDate is not None: if self._rule == DateGeneration.Backward or self._rule == DateGeneration.Forward: pyFinAssert(effectiveDate < self._nextToLastDate < terminationDate, ValueError, "next to last date ({0}) out of effective-termination date range [{1}, {2})" .format(self._nextToLastDate, effectiveDate, terminationDate)) # we should ensure that the above condition is still # verified after adjustment elif self._rule == DateGeneration.Zero: raise ValueError("next to last date incompatible with {0:d} date generation rule".format(self._rule)) else: raise ValueError("unknown rule ({0:d})".format(self._rule)) # calendar needed for endOfMonth adjustment nullCalendar = Calendar("Null") periods = 1 if self._rule == DateGeneration.Zero: self._tenor = Period(0, TimeUnits.Years) self._dates.extend([effectiveDate, terminationDate]) self._isRegular.append(True) elif self._rule == DateGeneration.Backward: self._dates.append(terminationDate) seed = terminationDate if self._nextToLastDate is not None: self._dates.insert(0, self._nextToLastDate) temp = nullCalendar.advanceDate(seed, Period(-periods * self._tenor.length, self._tenor.units), convention, self._endOfMonth) if temp != self._nextToLastDate: self._isRegular.insert(0, False) else: self._isRegular.insert(0, True) seed = self._nextToLastDate exitDate = effectiveDate if self._firstDate is not None: exitDate = self._firstDate while True: temp = nullCalendar.advanceDate(seed, Period(-periods * self._tenor.length, self._tenor.units), convention, self._endOfMonth) if temp < exitDate: if self._firstDate is not None and self._cal.adjustDate(self._dates[0], convention) != self._cal.adjustDate( self._firstDate, convention): self._dates.insert(0, self._firstDate) self._isRegular.insert(0, False) break else: # skip dates that would result in duplicates # after adjustment if self._cal.adjustDate(self._dates[0], convention) != self._cal.adjustDate(temp, convention): self._dates.insert(0, temp) self._isRegular.insert(0, True) periods += 1 if self._cal.adjustDate(self._dates[0], convention) != self._cal.adjustDate(effectiveDate, convention): self._dates.insert(0, effectiveDate) self._isRegular.insert(0, False) elif self._rule == DateGeneration.Forward: self._dates.append(effectiveDate) seed = self._dates[-1] if self._firstDate is not None: self._dates.append(self._firstDate) temp = nullCalendar.advanceDate(seed, Period(periods * self._tenor.length, self._tenor.units), convention, self._endOfMonth) if temp != self._firstDate: self._isRegular.append(False) else: self._isRegular.append(True) seed = self._firstDate exitDate = terminationDate if self._nextToLastDate is not None: exitDate = self._nextToLastDate while True: temp = nullCalendar.advanceDate(seed, Period(periods * self._tenor.length, self._tenor.units), convention, self._endOfMonth) if temp > exitDate: if self._nextToLastDate is not None and self._cal.adjustDate(self._dates[-1], convention) != self._cal.adjustDate( self._nextToLastDate, convention): self._dates.append(self._nextToLastDate) self._isRegular.append(False) break else: # skip dates that would result in duplicates # after adjustment if self._cal.adjustDate(self._dates[-1], convention) != self._cal.adjustDate(temp, convention): self._dates.append(temp) self._isRegular.append(True) periods += 1 if self._cal.adjustDate(self._dates[-1], terminationConvention) != self._cal.adjustDate(terminationDate, terminationConvention): self._dates.append(terminationDate) self._isRegular.append(False) else: raise ValueError("unknown rule ({0:d})".format(self._rule)) # adjustments if self._endOfMonth and self._cal.isEndOfMonth(seed): # adjust to end of month if convention == BizDayConventions.Unadjusted: for i in range(len(self._dates) - 1): self._dates[i] = Date.endOfMonth(self._dates[i]) else: for i in range(len(self._dates) - 1): self._dates[i] = self._cal.endOfMonth(self._dates[i]) if terminationConvention != BizDayConventions.Unadjusted: self._dates[0] = self._cal.endOfMonth(self._dates[0]) self._dates[-1] = self._cal.endOfMonth(self._dates[-1]) else: if self._rule == DateGeneration.Backward: self._dates[-1] = Date.endOfMonth(self._dates[-1]) else: self._dates[0] = Date.endOfMonth(self._dates[0]) else: for i in range(len(self._dates) - 1): self._dates[i] = self._cal.adjustDate(self._dates[i], convention) if terminationConvention != BizDayConventions.Unadjusted: self._dates[-1] = self._cal.adjustDate(self._dates[-1], terminationConvention) # Final safety checks to remove extra next-to-last date, if # necessary. It can happen to be equal or later than the end # date due to EOM adjustments (see the Schedule test suite # for an example). if len(self._dates) >= 2 and self._dates[len(self._dates) - 2] >= self._dates[-1]: self._isRegular[len(self._dates) - 2] = (self._dates[len(self._dates) - 2] == self._dates[-1]) self._dates[len(self._dates) - 2] = self._dates[-1] self._dates.pop() self._isRegular.pop() if len(self._dates) >= 2 and self._dates[1] <= self._dates[0]: self._isRegular[1] = (self._dates[1] == self._dates[0]) self._dates[1] = self._dates[0] self._dates = self._dates[1:] self._isRegular = self._isRegular[1:] pyFinAssert(len(self._dates) >= 1, ValueError, "degenerate single date ({0}) schedule\n" "seed date: {1}\n" "exit date: {2}\n" "effective date: {3}\n" "first date: {4}\n" "next to last date: {5}\n" "termination date: {6}\n" "generation rule: {7}\n" "end of month: {8}\n" .format(self._dates[0], seed, exitDate, effectiveDate, firstDate, nextToLastDate, terminationDate, self._rule, self._endOfMonth))
def testDailySchedule(self): # Jan 2 and Jan 3 are skipped as New Year holiday # Jan 7 is skipped as weekend # Jan 8 is adjusted to Jan 9 with following convention startDate = Date(2012, 1, 1) s = Schedule(startDate, startDate + 7, Period(length=1, units=TimeUnits.Days), Calendar("China.SSE"), BizDayConventions.Preceding) expected = [ Date(2011, 12, 30), Date(2012, 1, 4), Date(2012, 1, 5), Date(2012, 1, 6), Date(2012, 1, 9) ] self.checkDates(s, expected) # The schedule should skip Saturday 21st and Sunday 22rd. # Previously, it would adjust them to Friday 20th, resulting # in three copies of the same date. startDate = Date(2012, 1, 17) s = Schedule(startDate, startDate + 7, Period(length=1, units=TimeUnits.Days), Calendar("Target"), BizDayConventions.Preceding) expected = [ Date(2012, 1, 17), Date(2012, 1, 18), Date(2012, 1, 19), Date(2012, 1, 20), Date(2012, 1, 23), Date(2012, 1, 24) ] self.checkDates(s, expected)
def anchorEvaluationDate(self): if self._evaluationDate is None: self._evaluationDate = Date.todaysDate()
def evaluationDate(self): if self._evaluationDate is None: return Date.todaysDate() return self._evaluationDate
def isBizDay(holidayCenter, ref): cal = Calendar(holidayCenter) ref = Date.fromDateTime(ref) return cal.isBizDay(ref)
def holDatesList(holidayCenter, fromDate, toDate, includeWeekend=True): cal = Calendar(holidayCenter) fromDate = Date.fromDateTime(fromDate) toDate = Date.fromDateTime(toDate) assert fromDate <= toDate, "from date ({0} must be earlier than to date {1}".format(fromDate, toDate) return [d.toDateTime() for d in cal.holDatesList(fromDate, toDate, includeWeekend)]
def check_date(date): from PyFin.DateUtilities import Date if isinstance(date, str): return Date.strptime(date, dateFormat='%Y-%m-%d') else: return Date.fromDateTime(date)
def advanceDate(referenceDate, period): d = Date.fromDateTime(referenceDate) + period return d.toDateTime()