Example #1
0
def map_to_biz_day(date_series, calendar='China.SSE', convention=BizDayConventions.Preceding):
    """
    :param date_series: array-like of datetime.datetime
    :param calendar: str, optional, 日历名称,见PyFin.DateUtilities.Calendar, default='China.SSE'
    :param convention: str, optional, 如果日期为节假日,如何调整成交易日,见PyFin.DateUtilities.Schedule, default = preceding
    :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
Example #2
0
def map_to_biz_day(date_series,
                   calendar='China.SSE',
                   convention=BizDayConventions.Preceding):
    """
    :param date_series: array-like of datetime.datetime
    :param calendar: str, optional, 日历名称,见PyFin.DateUtilities.Calendar, default='China.SSE'
    :param convention: str, optional, 如果日期为节假日,如何调整成交易日,见PyFin.DateUtilities.Schedule, default = preceding
    :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
Example #3
0
    def test_BasicFunctions(self):
        year = 2015
        month = 7
        day = 24
        str_repr = "{0}-{1:02d}-{2:02d}".format(year, month, day)
        inner_repr = "Date({0}, {1}, {2})".format(year, month, day)

        test_date = Date(year, month, day)
        self.assertEqual(str(test_date), str_repr, "date string:\n"
                                                   "expected:   {0:s}\n"
                                                   "calculated: {1:s}".format(str_repr, str(test_date)))

        self.assertEqual(repr(test_date), inner_repr, "date representation:\n"
                                                      "expected:   {0:s}\n"
                                                      "calculated: {1:s}".format(inner_repr, repr(test_date)))

        self.assertEqual(test_date.year(), year, "date year:\n"
                                                 "expected:   {0:d}\n"
                                                 "calculated: {1:d}".format(year, test_date.year()))

        self.assertEqual(test_date.month(), month, "date month:\n"
                                                   "expected:   {0:d}\n"
                                                   "calculated: {1:d}".format(month, test_date.month()))

        self.assertEqual(test_date.dayOfMonth(), day, "date day:\n"
                                                      "expected:   {0:d}\n"
                                                      "calculated: {1:d}".format(day, test_date.dayOfMonth()))

        self.assertEqual(test_date.dayOfYear(), test_date - Date(2015, 1, 1) + 1, "date day:\n"
                                                                                  "expected:   {0:d}\n"
                                                                                  "calculated: {1:d}"
                         .format(test_date - Date(2015, 1, 1) + 1, test_date.dayOfYear()))
        self.assertEqual(test_date.weekday(), 6, "date weekday:\n"
                                                 "expected:   {0:d}\n"
                                                 "calculated: {1:d}".format(5, test_date.weekday()))

        self.assertEqual(test_date.toDateTime(), dt.datetime(year, month, day), "date datetime representation\n"
                                                                                "expected:   {0}\n"
                                                                                "calculated: {1}".format(
            dt.datetime(year, month, day), test_date.toDateTime()))

        serial_number = test_date.serialNumber
        serial_date = Date(serial_number=serial_number)

        self.assertEqual(serial_date, test_date, "date excel serial number representation\n"
                                                 "expected:   {0:d}"
                                                 "calculated: {1:d}".format(serial_date.serialNumber,
                                                                            test_date.serialNumber))

        # test comparisons
        previous_date = test_date - 1
        self.assertTrue(previous_date < test_date, "{0} is not earlier than {1}".format(previous_date, test_date))
        self.assertFalse(previous_date >= test_date,
                         "{0} should not be later than or equal to {1}".format(previous_date, test_date))
        self.assertTrue((previous_date + 1) == test_date,
                        "{0} plus one day should be equal to {1}".format(previous_date, test_date))

        # 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(test_date), 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(test_date, test_date.weekday()), test_date,
                         "{0}'s next same week day should be {1}"
                         .format(test_date, test_date))
        expected_date = dt.date.today()
        expected_date = dt.datetime(expected_date.year, expected_date.month, expected_date.day)
        self.assertEqual(Date.todaysDate().toDateTime(), expected_date, "today's date\n"
                                                                        "expected:   {0}\n"
                                                                        "calculated: {1}".format(expected_date,
                                                                                                 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

        three_weeks_after = test_date + '3W'
        expected_date = test_date + 21
        self.assertEqual(three_weeks_after, expected_date, "date + 3w period\n"
                                                           "expected:   {0}\n"
                                                           "calculated: {1}".format(expected_date, three_weeks_after))

        three_months_before = test_date - "3M"
        expected_date = Date(year, month - 3, day)
        self.assertEqual(three_months_before, expected_date, "date - 3m period\n"
                                                             "expected:   {0}\n"
                                                             "calculated: {1}".format(expected_date,
                                                                                      three_months_before))

        three_months_before = test_date - Period("3M")
        expected_date = Date(year, month - 3, day)
        self.assertEqual(three_months_before, expected_date, "date - 3m period\n"
                                                             "expected:   {0}\n"
                                                             "calculated: {1}".format(expected_date,
                                                                                      three_months_before))

        three_months_after = test_date + "3m"
        expected_date = Date(year, month + 3, day)
        self.assertEqual(three_months_after, expected_date, "date + 3m period\n"
                                                            "expected:   {0}\n"
                                                            "calculated: {1}".format(expected_date, three_months_after))

        one_year_and_two_months_before = test_date - "14m"
        expected_date = Date(year - 1, month - 2, day)
        self.assertEqual(one_year_and_two_months_before, expected_date, "date - 14m period\n"
                                                                        "expected:   {0}\n"
                                                                        "calculated: {1}".format(expected_date,
                                                                                                 three_months_before))

        one_year_and_two_months_before = test_date + "14m"
        expected_date = Date(year + 1, month + 2, day)
        self.assertEqual(one_year_and_two_months_before, expected_date, "date + 14m period\n"
                                                                        "expected:   {0}\n"
                                                                        "calculated: {1}".format(expected_date,
                                                                                                 three_months_before))

        five_months_after = test_date + "5m"
        expected_date = Date(year, month + 5, day)
        self.assertEqual(five_months_after, expected_date, "date + 5m period\n"
                                                           "expected:   {0}\n"
                                                           "calculated: {1}".format(expected_date, five_months_after))