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, [])