def test_tcs_tce_always_full_days(self):
tcs_reference_dt = datetime(2018, 4, 1, 0, 0, 0)
tce_reference_dt = datetime(2018, 5, 1) - relativedelta(microseconds=1)
prd = dateperiods.DatePeriod([2018, 4], [2018, 4])
self.assertEqual(prd.tcs.dt, tcs_reference_dt)
self.assertEqual(prd.tce.dt, tce_reference_dt)
prd = dateperiods.DatePeriod(datetime(2018, 4, 1),
datetime(2018, 4, 30))
self.assertEqual(prd.tcs.dt, tcs_reference_dt)
self.assertEqual(prd.tce.dt, tce_reference_dt)
def test_full_overlap(self):
prd = dateperiods.DatePeriod([2018, 4], [2018, 4])
self.assertTrue(
prd.has_overlap(dateperiods.DatePeriod([2018, 4], [2018, 4])))
self.assertTrue(
prd.has_overlap(dateperiods.DatePeriod([2018, 3], [2018, 4])))
self.assertTrue(
prd.has_overlap(dateperiods.DatePeriod([2018, 4], [2018, 5])))
self.assertTrue(
prd.has_overlap(dateperiods.DatePeriod([2018, 3], [2018, 5])))
def test_partial_intersection(self):
prd = dateperiods.DatePeriod([2018, 4], [2018, 4])
# Test 1: period start earlier
prd_intersect = dateperiods.DatePeriod([2018, 4, 15], [2018, 5])
result = prd.intersect(prd_intersect)
self.assertEqual(result.tcs.date, prd_intersect.tcs.date)
self.assertEqual(result.tce.date, prd.tce.date)
# Test 2: period ends later
prd_intersect = dateperiods.DatePeriod([2018, 3], [2018, 4, 15])
result = prd.intersect(prd_intersect)
self.assertEqual(result.tcs.date, prd.tcs.date)
self.assertEqual(result.tce.date, prd_intersect.tce.date)
def test_month_filter_yearly_duration(self):
prd = dateperiods.DatePeriod([2010], [2011])
segments = prd.get_segments("year")
months_to_exclude = [5, 6, 7, 8, 9]
# filtering should not do anything
segments.filter_month(months_to_exclude)
self.assertEqual(segments.n_periods, 2)
def test_month_filter_empty_result(self):
prd = dateperiods.DatePeriod([2010, 6], [2010, 8])
segments = prd.get_segments("month")
months_to_exclude = [5, 6, 7, 8, 9]
# filtering should not do anything
segments.filter_month(months_to_exclude)
self.assertEqual(segments.n_periods, 0)
def test_segment_lengths_isoweeks(self):
prd = dateperiods.DatePeriod([2018, 4], [2018, 4])
segments = prd.get_segments("isoweek")
self.assertEqual(segments.n_periods, 5)
for segment in segments:
self.assertTrue(segment.tcs.is_monday)
self.assertTrue(segment.tce.is_sunday)
def test_segment_lengths_months(self):
prd = dateperiods.DatePeriod([2018, 3], [2018, 4])
segments = prd.get_segments("month")
self.assertEqual(segments.n_periods, 2)
for segment in segments:
self.assertEqual(segment.tcs.dt.day, 1)
self.assertTrue(segment.tce.is_last_day_of_month)
def test_input_args(self):
prd = dateperiods.DatePeriod([2010], [2010])
segments = prd.get_segments("month")
self.assertRaises(TypeError, segments.filter_month)
self.assertRaises(ValueError, segments.filter_month, "monthly")
self.assertRaises(ValueError, segments.filter_month, ["monthly"])
self.assertRaises(ValueError, segments.filter_month, 0)
self.assertRaises(ValueError, segments.filter_month, 13)
def test_month_filter_daily_duration(self):
prd = dateperiods.DatePeriod([2011], [2011])
segments = prd.get_segments("day")
months_to_exclude = [5, 6, 7, 8, 9]
segments.filter_month(months_to_exclude)
# 2011 is not a leap year, month May through Sep are 153 days
# -> 365 - 153 = 212
self.assertEqual(segments.n_periods, 212)
# Do that again, but with a leap year
prd = dateperiods.DatePeriod([2020], [2020])
segments = prd.get_segments("day")
months_to_exclude = [5, 6, 7, 8, 9]
segments.filter_month(months_to_exclude)
# 2011 is not a leap year, month May through Sep are 153 days
# -> 366 - 153 = 213
self.assertEqual(segments.n_periods, 213)
def test_duration_months(self):
prd = dateperiods.DatePeriod([2018, 10], [2019, 4])
duration = prd.duration
self.assertFalse(duration.is_month)
self.assertFalse(duration.is_day)
self.assertFalse(duration.is_isoweek)
self.assertFalse(duration.is_year)
self.assertEqual(duration.isoformat, "P7M")
self.assertEqual(duration.type, "custom")
def test_segment_lengths_years(self):
prd = dateperiods.DatePeriod([2018, 3], [2019, 4])
segments = prd.get_segments("year")
self.assertEqual(segments.n_periods, 2)
for segment in segments:
self.assertEqual(segment.tcs.day, 1)
self.assertEqual(segment.tcs.month, 1)
self.assertEqual(segment.tce.day, 31)
self.assertEqual(segment.tce.month, 12)
def test_duration_isoweek(self):
prd = dateperiods.DatePeriod([2018, 4, 2], [2018, 4, 8])
duration = prd.duration
self.assertTrue(duration.is_isoweek)
self.assertFalse(duration.is_day)
self.assertFalse(duration.is_month)
self.assertFalse(duration.is_year)
self.assertEqual(duration.isoformat, "P7D")
self.assertEqual(duration.type, "isoweek")
def test_netcdf_attribute_dict(self):
prd = dateperiods.DatePeriod([2018, 4, 1], [2018, 4, 1])
attr_dict = prd.get_netcdf_attributes(zulu=True)
self.assertTrue("time_coverage_start" in attr_dict)
self.assertEqual(attr_dict["time_coverage_start"], "20180401T000000Z")
self.assertTrue("time_coverage_end" in attr_dict)
self.assertEqual(attr_dict["time_coverage_end"], "20180401T235959Z")
self.assertTrue("time_coverage_duration" in attr_dict)
self.assertEqual(attr_dict["time_coverage_duration"], "P1D")
self.assertTrue("time_coverage_resolution" in attr_dict)
self.assertEqual(attr_dict["time_coverage_resolution"], "P1D")
def test_cropped_segment_type_yearly(self):
prd = dateperiods.DatePeriod([2018, 4, 15], [2019, 5, 15])
segments = prd.get_segments("year", crop_to_period=True)
self.assertEqual(segments.n_periods, 2)
# Test first segment (should be Apr 15 -> Apr. 30)
first_segment = segments.list[0]
self.assertEqual(first_segment.tcs.date, date(2018, 4, 15))
self.assertEqual(first_segment.tce.date, date(2018, 12, 31))
# Test second segment (should be May 1 -> May 15)
second_segment = segments.list[1]
self.assertEqual(second_segment.tcs.date, date(2019, 1, 1))
self.assertEqual(second_segment.tce.date, date(2019, 5, 15))
def test_partial_overlap(self):
prd = dateperiods.DatePeriod([2018, 4, 15], [2018, 5, 15])
self.assertTrue(
prd.has_overlap(dateperiods.DatePeriod([2018, 4], [2018, 4])))
self.assertTrue(
prd.has_overlap(dateperiods.DatePeriod([2018, 5], [2018, 5])))
self.assertTrue(
prd.has_overlap(dateperiods.DatePeriod([2018, 4], [2018, 4, 15])))
self.assertTrue(
prd.has_overlap(dateperiods.DatePeriod([2018, 5, 15], [2018, 5])))
self.assertTrue(
prd.has_overlap(dateperiods.DatePeriod([2018, 4, 16], [2018, 4])))
def test_input_args(self):
prd = dateperiods.DatePeriod([2018, 4, 15], [2018, 5, 15])
self.assertIsInstance(prd.get_segments("month", crop_to_period=True),
dateperiods.PeriodIterator)
self.assertIsInstance(prd.get_segments("month", crop_to_period=False),
dateperiods.PeriodIterator)
self.assertRaises(ValueError,
prd.get_segments,
"monthly",
crop_to_period=1)
self.assertRaises(ValueError,
prd.get_segments,
"monthly",
crop_to_period="a")
self.assertRaises(ValueError,
prd.get_segments,
"monthly",
crop_to_period=None)
def test_input_args(self):
prd = dateperiods.DatePeriod([2018, 4], [2018, 4])
self.assertRaises(TypeError, prd.intersect)
self.assertRaises(ValueError, prd.intersect, 1)
self.assertRaises(ValueError, prd.intersect, None)
self.assertRaises(ValueError, prd.intersect, [])
def test_no_overlap(self):
prd = dateperiods.DatePeriod([2018, 4, 15], [2018, 5, 15])
self.assertFalse(
prd.has_overlap(dateperiods.DatePeriod([2018, 4], [2018, 4, 14])))
self.assertFalse(
prd.has_overlap(dateperiods.DatePeriod([2018, 5, 16], [2018, 5])))
def test_segment_iterator(self):
prd = dateperiods.DatePeriod([2018, 4], [2018, 4])
segments = prd.get_segments("day")
for segment in segments:
self.assertIsInstance(segment, dateperiods.DatePeriod)
def test_segment_lengths_days(self):
prd = dateperiods.DatePeriod([2018, 4], [2018, 5])
segments = prd.get_segments("day")
self.assertEqual(segments.n_periods, 61)
for segment in segments:
self.assertEqual(segment.tcs.date, segment.tce.date)
def test_full_intersection(self):
prd = dateperiods.DatePeriod([2018, 4], [2018, 4])
prd_intersect = dateperiods.DatePeriod([2018, 2], [2018, 5])
result = prd.intersect(prd_intersect)
self.assertEqual(result.tcs.date, prd.tcs.date)
self.assertEqual(result.tce.date, prd.tce.date)
def test_date_flags(self):
prd = dateperiods.DatePeriod([2018, 4], [2018, 4])
self.assertTrue(prd.tcs.is_tcs)
self.assertFalse(prd.tcs.is_tce)
self.assertTrue(prd.tce.is_tce)
self.assertFalse(prd.tce.is_tcs)
def test_month_filter_monthly_duration(self):
prd = dateperiods.DatePeriod([2010], [2010])
segments = prd.get_segments("month")
months_to_exclude = [5, 6, 7, 8, 9]
segments.filter_month(months_to_exclude)
self.assertEqual(segments.n_periods, 7)
def test_empty_intersection(self):
prd = dateperiods.DatePeriod([2018, 4], [2018, 4])
prd_intersect = dateperiods.DatePeriod([2018, 3], [2018, 3])
self.assertIsNone(prd.intersect(prd_intersect))
prd_intersect = dateperiods.DatePeriod([2018, 5], [2018, 5])
self.assertIsNone(prd.intersect(prd_intersect))
def test_cropped_segment_type_daily(self):
prd = dateperiods.DatePeriod([2018, 4, 15], [2018, 5, 15])
segments = prd.get_segments("day", crop_to_period=True)
self.assertEqual(segments.n_periods, 31)
def test_input_args(self):
prd = dateperiods.DatePeriod([2018, 4], [2018, 4])
self.assertRaises(TypeError, prd.get_segments)
self.assertRaises(ValueError, prd.get_segments, None)
self.assertRaises(ValueError, prd.get_segments, "a")
self.assertRaises(ValueError, prd.get_segments, 1)
def test_input_args(self):
prd = dateperiods.DatePeriod([2018, 4], [2018, 4])
self.assertRaises(TypeError, prd.has_overlap)
self.assertRaises(ValueError, prd.has_overlap, 1)
self.assertRaises(ValueError, prd.has_overlap, None)
self.assertRaises(ValueError, prd.has_overlap, [])
