Пример #1
0
    def test_slicing(self):
        dates = [
            datetime.date(2019, 8, 15),
            datetime.date(2019, 8, 16),
            datetime.date(2019, 8, 19),
            datetime.date(2019, 8, 20),
        ]
        cdr = Calendar(dates)

        self.assertEqual(cdr[0:2], Calendar(dates[0:2]))
        self.assertEqual(cdr[-2:], Calendar(dates[-2:]))
        self.assertEqual(cdr[datetime.date(2019, 8, 1) :], cdr)
        self.assertEqual(
            cdr[datetime.date(2019, 8, 15) :][0], datetime.date(2019, 8, 15)
        )
        self.assertEqual(
            cdr[datetime.date(2019, 8, 17) :][0], datetime.date(2019, 8, 19)
        )
        self.assertEqual(len(cdr[datetime.date(2019, 8, 21) :]), 0)
        self.assertEqual(
            cdr[: datetime.date(2019, 8, 18)][-1], datetime.date(2019, 8, 16)
        )
        self.assertEqual(
            cdr[: datetime.date(2019, 8, 19)][-1], datetime.date(2019, 8, 19)
        )
        self.assertEqual(
            cdr[: datetime.date(2019, 8, 22)][-1], datetime.date(2019, 8, 20)
        )
        self.assertEqual(len(cdr[: datetime.date(2019, 8, 1)]), 0)
Пример #2
0
    def test_filter(self):
        dates = [
            datetime.date(2019, 8, 15),
            datetime.date(2019, 8, 16),
            datetime.date(2019, 8, 19),
            datetime.date(2019, 8, 20),
        ]
        cdr = Calendar(dates)

        self.assertEqual(cdr.filter(weekday=4), Calendar([datetime.date(2019, 8, 16)]))
Пример #3
0
    def test_init(self):
        with self.assertRaises(Exception):
            self.assertIsInstance(Calendar(), Calendar)

        self.assertIsInstance(Calendar([]), Calendar)
        self.assertIsInstance(Calendar([datetime.date.today()]), Calendar)
        self.assertIsInstance(
            Calendar(pd.date_range(datetime.date.today(), freq="D", periods=10)),
            Calendar,
        )
        with self.assertRaises(Exception):
            cdr = Calendar(True)
Пример #4
0
    def test_lb(self):
        dates = [
            datetime.date(2019, 8, 15),
            datetime.date(2019, 8, 16),
            datetime.date(2019, 8, 19),
            datetime.date(2019, 8, 20),
        ]
        cdr = Calendar(dates)

        self.assertEqual(cdr.lb(datetime.date(2019, 8, 16)), datetime.date(2019, 8, 15))
        self.assertEqual(cdr.lb(datetime.date(2019, 8, 17)), datetime.date(2019, 8, 16))
        self.assertEqual(cdr.lb(datetime.date(2019, 8, 30)), datetime.date(2019, 8, 20))
        self.assertEqual(cdr.lb(datetime.date(2019, 8, 1), None), None)
Пример #5
0
    def test_inversing_with_no_bounds(self):
        calendar = Calendar(
            [datetime.date(2022, 1, 17), datetime.date(2022, 2, 14)]
        ).inverse()

        assert calendar[0] == datetime.date(2022, 1, 18)
        assert calendar[-1] == datetime.date(2022, 2, 13)
Пример #6
0
def load():
    with open(os.path.join(os.path.dirname(__file__), "calendar.csv"),
              "r") as f:
        return Calendar([
            datetime.datetime.strptime(date, "%Y-%m-%d").date()
            for date in f.read().strip().split("\n")
        ])
Пример #7
0
    def test_setmethods(self):
        c1 = Calendar(
            [
                datetime.date(2019, 7, 14),
                datetime.date(2019, 7, 29),
                datetime.date(2019, 8, 15),
                datetime.date(2019, 8, 16),
                datetime.date(2019, 8, 19),
            ]
        )

        c2 = Calendar(
            [
                datetime.date(2019, 7, 14),
                datetime.date(2019, 7, 20),
                datetime.date(2019, 8, 15),
                datetime.date(2019, 8, 17),
                datetime.date(2019, 8, 19),
            ]
        )

        self.assertEqual(c1.union(c2), Calendar(set(c1.dates).union(c2.dates)))

        self.assertEqual(
            c1.intersection(c2), Calendar(set(c1.dates).intersection(set(c2.dates)))
        )
Пример #8
0
    def test_indexing(self):
        cal = Calendar(
            [datetime.date(2019, 1, 1) + datetime.timedelta(i) for i in range(45)]
        )

        self.assertEqual(cal[0], datetime.date(2019, 1, 1))
        self.assertEqual(cal[-1], datetime.date(2019, 2, 14))
        self.assertEqual(cal[0:31][-1], datetime.date(2019, 1, 31))
        self.assertEqual(cal[:31][0], datetime.date(2019, 1, 1))
Пример #9
0
    def test_inversing_with_bounds(self):
        calendar = Calendar(
            [datetime.date(2022, 1, 17), datetime.date(2022, 2, 14)]
        ).inverse(datetime.date(2022, 1, 1), datetime.date(2022, 12, 31))

        assert calendar[0] == datetime.date(2022, 1, 1)
        assert calendar[-1] == datetime.date(2022, 12, 31)

        assert datetime.date(2022, 1, 17) not in calendar
        assert datetime.date(2022, 2, 14) not in calendar
        assert len(calendar) == 365 - 2

        # test with starting date equal to a holiday
        calendar = Calendar(
            [datetime.date(2022, 1, 17), datetime.date(2022, 2, 14)]
        ).inverse(datetime.date(2022, 1, 17), datetime.date(2022, 12, 31))

        assert calendar[0] == datetime.date(2022, 1, 18)
Пример #10
0
    def test_generate(self):
        calendar = Calendar.generate(datetime.date(2021, 1, 1),
                                     datetime.date(2021, 12, 31))

        assert len(calendar) == 365
        assert calendar[0] == datetime.date(2021, 1, 1)
        assert calendar[-1] == datetime.date(2021, 12, 31)

        calendar = Calendar.generate(datetime.date(2021, 1, 1),
                                     datetime.date(2021, 1, 1))

        assert len(calendar) == 1
        assert calendar[0] == calendar[-1] == datetime.date(2021, 1, 1)

        # test if starting > ending date
        calendar = Calendar.generate(datetime.date(2021, 12, 31),
                                     datetime.date(2021, 1, 1))

        assert len(calendar) == 0
Пример #11
0
    def test_first_last(self):
        dates = [
            datetime.date(2019, 8, 15),
            datetime.date(2019, 8, 16),
            datetime.date(2019, 8, 19),
            datetime.date(2019, 8, 20),
        ]
        cdr = Calendar(dates)

        self.assertEqual(cdr.first, datetime.date(2019, 8, 15))
        self.assertEqual(cdr.last, datetime.date(2019, 8, 20))
Пример #12
0
    def test_lb(self):
        dates = [
            datetime.date(2019, 8, 15),
            datetime.date(2019, 8, 16),
            datetime.date(2019, 8, 19),
            datetime.date(2019, 8, 20),
        ]
        cdr = Calendar(dates)

        self.assertEqual(dates[0] in cdr, True)

        self.assertEqual(dates[-1] in cdr, True)

        self.assertEqual(datetime.date(2019, 8, 17) in cdr, False)
Пример #13
0
    def test_dayof(self):
        dates = [
            datetime.date(2019, 7, 14),
            datetime.date(2019, 7, 29),
            datetime.date(2019, 8, 15),
            datetime.date(2019, 8, 16),
            datetime.date(2019, 8, 19),
            datetime.date(2019, 8, 20),
        ]
        cdr = Calendar(dates)

        self.assertEqual(cdr.dayof("M")[dates[0]], 1)
        self.assertEqual(cdr.dayof("M")[dates[1]], 2)
        self.assertEqual(cdr.dayof("M")[dates[3]], 2)
        self.assertEqual(cdr.dayof("Y")[dates[3]], 4)
        self.assertEqual(cdr.dayof("W")[dates[4]], 1)
        self.assertEqual(cdr.dayof("W")[dates[-1]], 2)
Пример #14
0
    def test_snap(self):
        dates = [
            datetime.date(2019, 7, 14),
            datetime.date(2019, 7, 29),
            datetime.date(2019, 8, 15),
            datetime.date(2019, 8, 16),
            datetime.date(2019, 8, 19),
            datetime.date(2019, 8, 20),
        ]
        cdr = Calendar(dates)

        refdates = [
            datetime.date(2019, 7, 14),
            datetime.date(2019, 7, 20),
            datetime.date(2019, 8, 15),
            datetime.date(2019, 8, 17),
            datetime.date(2019, 8, 19),
            datetime.date(2019, 8, 20),
        ]
        ref = Calendar(refdates)

        snapped = cdr.snap(ref)

        self.assertEqual(list(snapped),
                         [dates[0], dates[2], dates[4], dates[5]])

        snapped = cdr.snap(ref, fallback="next")

        self.assertEqual(
            list(snapped),
            [refdates[0], refdates[2], refdates[3], refdates[4], refdates[5]],
        )

        snapped = cdr.snap(ref, fallback="previous")

        self.assertEqual(
            list(snapped),
            [refdates[0], refdates[1], refdates[2], refdates[4], refdates[5]],
        )
Пример #15
0
    def test_groupby(self):
        dates = [
            datetime.date(2019, 8, 15),
            datetime.date(2019, 8, 16),
            datetime.date(2019, 8, 19),
            datetime.date(2019, 8, 20),
        ]
        cdr = Calendar(dates)

        self.assertEqual(cdr.groupby("W").first(), Calendar([dates[0], dates[2]]))
        self.assertEqual(cdr.groupby("M").first(), Calendar([dates[0]]))
        self.assertEqual(cdr.groupby("Y").last(), Calendar([dates[-1]]))
        self.assertEqual(
            cdr.groupby("W").apply(lambda c: c[0:1]).combine(),
            Calendar(dates[0:1] + dates[2:3]),
        )
        self.assertEqual(
            cdr.groupby("W").apply(lambda c: c[0]).combine(),
            Calendar(dates[0:1] + dates[2:3]),
        )