def _compareReconvertibleText(self, nltext, src_time):
original = date_range_parser.parse(nltext, src_time)
original_res = original.get(u'result')
recon_text = original.get(u'parse')[0].get(u'reconvertible_text')
recon = date_range_parser.parse(recon_text, src_time)
recon_res = recon.get(u'result')
self.assertEqual(original_res, recon_res)
def test_preprocessing(self):
d8_3 = self.timezone.localize(datetime.datetime(2014, 8, 3))
r1 = date_range_parser.parse("tomorrow in the morning", d8_3).get(u'result')
self._compareResults(r1[0], (d8_3+timedelta(hours=(24+8)), d8_3+timedelta(hours=(24+11))))
self.assertEqual(len(r1), 1)
r2 = date_range_parser.parse("tomorrow from noon to 3 pm", d8_3).get(u'result')
self._compareResults(r2[0], (d8_3+timedelta(hours=(24+12)), d8_3+timedelta(hours=(24+15))))
self.assertEqual(len(r2), 1)
def test_between(self):
d8_3 = self.timezone.localize(datetime.datetime(2014, 8, 3))
d8_11 = self.timezone.localize(datetime.datetime(2014, 8, 11))
d8_15 = self.timezone.localize(datetime.datetime(2014, 8, 15))
monday = self.timezone.localize(datetime.datetime(2014, 8, 4))
tuesday = self.timezone.localize(datetime.datetime(2014, 8, 5))
wednesday = self.timezone.localize(datetime.datetime(2014, 8, 6))
thursday = self.timezone.localize(datetime.datetime(2014, 8, 7))
friday = self.timezone.localize(datetime.datetime(2014, 8, 8))
r1 = date_range_parser.parse("between 8/11 and 8/15", d8_3).get(u'result')
self._compareResults(r1[0], (d8_11, d8_11+timedelta(days=1)))
self._compareResults(r1[-1], (d8_15, d8_15 + timedelta(days=1)))
self.assertEqual(len(r1), 5)
r1 = date_range_parser.parse("from 8/11 to 8/15", d8_3).get(u'result')
self._compareResults(r1[0], (d8_11, d8_11+timedelta(days=1)))
self._compareResults(r1[-1], (d8_15, d8_15 + timedelta(days=1)))
self.assertEqual(len(r1), 5)
r1 = date_range_parser.parse("8/11/2014 - 8/15/2014", d8_3).get(u'result')
self._compareResults(r1[0], (d8_11, d8_11+timedelta(days=1)))
self._compareResults(r1[-1], (d8_15, d8_15 + timedelta(days=1)))
self.assertEqual(len(r1), 5)
r1 = date_range_parser.parse("8/11-8/15", d8_3).get(u'result')
self._compareResults(r1[0], (d8_11, d8_11+timedelta(days=1)))
self._compareResults(r1[-1], (d8_15, d8_15 + timedelta(days=1)))
self.assertEqual(len(r1), 5)
r1 = date_range_parser.parse("8.11-8.15", d8_3).get(u'result')
self._compareResults(r1[0], (d8_11, d8_11+timedelta(days=1)))
self._compareResults(r1[-1], (d8_15, d8_15 + timedelta(days=1)))
self.assertEqual(len(r1), 5)
r1 = date_range_parser.parse("between monday and thursday", d8_3).get(u'result')
self._compareResults(r1[0], (monday, tuesday))
self._compareResults(r1[-1], (thursday, friday))
self.assertEqual(len(r1), 4)
r1 = date_range_parser.parse("monday - thursday", d8_3).get(u'result')
self._compareResults(r1[0], (monday, tuesday))
self._compareResults(r1[-1], (thursday, friday))
self.assertEqual(len(r1), 4)
r1 = date_range_parser.parse("from monday to thursday", d8_3).get(u'result')
self._compareResults(r1[0], (monday, tuesday))
self._compareResults(r1[-1], (thursday, friday))
self.assertEqual(len(r1), 4)
#r1 = date_range_parser.parse("from monday morning to thursday evening", d8_3)
#self._compareResults(r1[0], (monday + timedelta(hours=8), tuesday))
#self._compareResults(r1[-1], (thursday, thursday + timedelta(hours=21)))
##self.assertEqual(len(r1), 4)
r1 = date_range_parser.parse("from monday thru thursday", d8_3).get(u'result')
self._compareResults(r1[0], (monday, tuesday))
self._compareResults(r1[-1], (thursday, friday))
self.assertEqual(len(r1), 4)
def test_reldr(self):
d8_3 = self.timezone.localize(datetime.datetime(2014, 8, 3))
d9_15 = self.timezone.localize(datetime.datetime(2014, 9, 15))
d9_19 = self.timezone.localize(datetime.datetime(2014, 9, 19))
r1 = date_range_parser.parse("2 weeks from 9/2", d8_3).get(u'result')
self._compareResults(r1[0], (d9_15, d9_15+timedelta(days=1)))
self._compareResults(r1[-1], (d9_19, d9_19+timedelta(days=1)))
self.assertEqual(len(r1), 5)
r1 = date_range_parser.parse("in three weeks from 9/2", d8_3).get(u'result')
self._compareResults(r1[0], (d9_15 + timedelta(days=7), d9_15+timedelta(days=1+7)))
self._compareResults(r1[-1], (d9_19 + timedelta(days=7), d9_19+timedelta(days=1+7)))
self.assertEqual(len(r1), 5)
def test_reject(self):
d8_3 = self.timezone.localize(datetime.datetime(2014, 8, 3))
r1 = date_range_parser.parse("set up a 20 minute meeting with [email protected]", d8_3).get(u'result')
self.assertEqual(len(r1), 0)
def test_absolute_one_way_inner_multiday_modifications(self):
d8_3 = self.timezone.localize(datetime.datetime(2014, 8, 3))
monday = d8_3 + timedelta(days=1) # Monday.
tuesday = monday + timedelta(days=1)
wednesday = tuesday + timedelta(days=1)
thursday = wednesday + timedelta(days=1)
friday = thursday + timedelta(days=1)
saturday = friday + timedelta(days=1)
sunday = saturday + timedelta(days=1)
r1 = date_range_parser.parse("before tuesday", monday).get(u'result')
recon = date_range_parser.parse("before tuesday", monday).get(u'parse')[0].get(u'reconvertible_text')
self.assertEqual(r1, date_range_parser.parse(recon, monday).get(u'result'))
self._compareResults(r1[0], (monday, tuesday))
self.assertEqual(len(r1), 1)
r1 = date_range_parser.parse("before 8/11", monday).get(u'result')
self._compareResults(r1[0], (monday, tuesday))
self.assertEqual(len(r1), 7)
r1 = date_range_parser.parse("before 08/11", monday).get(u'result')
self._compareResults(r1[0], (monday, tuesday))
self.assertEqual(len(r1), 7)
r1 = date_range_parser.parse("before 08/11/2014", monday).get(u'result')
self._compareResults(r1[0], (monday, tuesday))
self.assertEqual(len(r1), 7)
r1 = date_range_parser.parse("before 8/11/2014", monday).get(u'result')
self._compareResults(r1[0], (monday, tuesday))
self.assertEqual(len(r1), 7)
r1 = date_range_parser.parse("before 8.11", monday).get(u'result')
self._compareResults(r1[0], (monday, tuesday))
self.assertEqual(len(r1), 7)
r1 = date_range_parser.parse("before 8.11.2014", monday).get(u'result')
self._compareResults(r1[0], (monday, tuesday))
self.assertEqual(len(r1), 7)
r1 = date_range_parser.parse("after tuesday", monday).get(u'result')
self._compareResults(r1[0], (wednesday, wednesday+timedelta(days=1)))
self._compareResults(r1[-1], (wednesday+timedelta(days=13), wednesday+timedelta(days=14)))
self.assertEqual(len(r1), 14)
# Should just give us 0 minutes on Monday.
r1 = date_range_parser.parse("before this week", monday).get(u'result')
self._compareResults(r1[0], (monday, monday))
self.assertEqual(len(r1), 1)
r1 = date_range_parser.parse("before this week", wednesday).get(u'result')
self._compareResults(r1[0], (wednesday, wednesday))
self.assertEqual(len(r1), 1)
r1 = date_range_parser.parse("before next week", wednesday).get(u'result')
self._compareResults(r1[0], (wednesday, thursday))
self._compareResults(r1[-1], (sunday, sunday+timedelta(days=1)))
self.assertEqual(len(r1), 5) # wed, thur, fri, sat, sun = 5
r1 = date_range_parser.parse("after this week", monday).get(u'result')
self._compareResults(r1[0], (saturday, sunday))
self._compareResults(r1[-1], (saturday + timedelta(days=13), sunday + timedelta(days=13)))
self.assertEqual(len(r1), 14)
def test_absolute_one_way_inner_day_modifications(self):
d8_3 = self.timezone.localize(datetime.datetime(2014, 8, 3))
d8_4 = d8_3 + timedelta(days=1) # Monday.
tomorrow_before_10 = (d8_4, d8_4 + timedelta(hours=10))
tomorrow_after_10 = (d8_4 + timedelta(hours=10), d8_4+timedelta(days=1))
tomorrow_before_14 = (d8_4, d8_4 + timedelta(hours=14))
tomorrow_after_14 = (d8_4 + timedelta(hours=14), d8_4+timedelta(days=1))
r1 = date_range_parser.parse("tomorrow before 10 Am", d8_3).get(u'result')
self._compareResults(r1[0], tomorrow_before_10)
self.assertEqual(len(r1), 1)
r1 = date_range_parser.parse("tomorrow before 10 am", d8_3).get(u'result')
self._compareResults(r1[0], tomorrow_before_10)
self.assertEqual(len(r1), 1)
r1 = date_range_parser.parse("tomorrow before 10:00 AM", d8_3).get(u'result')
self._compareResults(r1[0], tomorrow_before_10)
self.assertEqual(len(r1), 1)
r1 = date_range_parser.parse("tomorrow before 10:00 A.M.", d8_3).get(u'result')
self._compareResults(r1[0], tomorrow_before_10)
self.assertEqual(len(r1), 1)
r1 = date_range_parser.parse("tomorrow after 10 Am", d8_3).get(u'result')
self._compareResults(r1[0], tomorrow_after_10)
self.assertEqual(len(r1), 1)
r1 = date_range_parser.parse("tomorrow after 10 am", d8_3).get(u'result')
self._compareResults(r1[0], tomorrow_after_10)
self.assertEqual(len(r1), 1)
r1 = date_range_parser.parse("tomorrow after 10:00 AM", d8_3).get(u'result')
self._compareResults(r1[0], tomorrow_after_10)
self.assertEqual(len(r1), 1)
r1 = date_range_parser.parse("tomorrow after 10:00 A.M.", d8_3).get(u'result')
self._compareResults(r1[0], tomorrow_after_10)
self.assertEqual(len(r1), 1)
r1 = date_range_parser.parse("tomorrow before 2", d8_3).get(u'result')
self._compareResults(r1[0], tomorrow_before_14)
self.assertEqual(len(r1), 1)
r1 = date_range_parser.parse("tomorrow before 2 pm", d8_3).get(u'result')
self._compareResults(r1[0], tomorrow_before_14)
self.assertEqual(len(r1), 1)
r1 = date_range_parser.parse("tomorrow before 14:00", d8_3).get(u'result')
self._compareResults(r1[0], tomorrow_before_14)
self.assertEqual(len(r1), 1)
r1 = date_range_parser.parse("tomorrow before 14 ", d8_3).get(u'result')
self._compareResults(r1[0], tomorrow_before_14)
self.assertEqual(len(r1), 1)
r1 = date_range_parser.parse("tomorrow before 14 am ", d8_3).get(u'result')
self._compareResults(r1[0], tomorrow_before_14)
self.assertEqual(len(r1), 1)
r1 = date_range_parser.parse("tomorrow before 2:00 P.M.", d8_3).get(u'result')
self._compareResults(r1[0], tomorrow_before_14)
self.assertEqual(len(r1), 1)
r1 = date_range_parser.parse("tomorrow after 2 Pm", d8_3).get(u'result')
self._compareResults(r1[0], tomorrow_after_14)
self.assertEqual(len(r1), 1)
r1 = date_range_parser.parse("tomorrow after 2 pm", d8_3).get(u'result')
self._compareResults(r1[0], tomorrow_after_14)
self.assertEqual(len(r1), 1)
r1 = date_range_parser.parse("tomorrow after 2:00 PM", d8_3).get(u'result')
self._compareResults(r1[0], tomorrow_after_14)
self.assertEqual(len(r1), 1)
r1 = date_range_parser.parse("tomorrow after 2:00 P.M.", d8_3).get(u'result')
self._compareResults(r1[0], tomorrow_after_14)
self.assertEqual(len(r1), 1)
def test_natural_inner_day_modifications(self):
def construct_time(hr1, hr2):
return (d8_4 + datetime.timedelta(hours=hr1), d8_4 + datetime.timedelta(hours=hr2))
d8_3 = self.timezone.localize(datetime.datetime(2014, 8, 3))
d8_4 = d8_3 + datetime.timedelta(days=1)
td_8 = datetime.timedelta(hours=8)
td_1030 = datetime.timedelta(hours=10.5)
tomorrow_emorning = construct_time(5,8)
tomorrow_morning = construct_time(8,11)
tomorrow_lmorning = construct_time(10,11.5)
tomorrow_brunch = construct_time(10,14)
tomorrow_elunch = construct_time(11,12)
tomorrow_lunch = construct_time(11,13)
tomorrow_llunch = construct_time(13,14.5)
tomorrow_eafternoon = construct_time(12,15)
tomorrow_afternoon = construct_time(12, 16)
tomorrow_lafternoon = construct_time(14.5, 16.5)
tomorrow_eevening = construct_time(16,18)
tomorrow_evening = construct_time(17,20)
tomorrow_levening = construct_time(19,22)
tomorrow_enight = construct_time(19,21)
tomorrow_night = construct_time(19, 22.5)
tomorrow_lnight = construct_time(22, 23.5)
r1 = date_range_parser.parse(u'tomorrow morning', d8_3).get(u'result')
self._compareResults(r1[0], tomorrow_morning)
self.assertEqual(len(r1), 1)
r1 = date_range_parser.parse(u'tomorrow early morning', d8_3).get(u'result')
self._compareResults(r1[0], tomorrow_emorning)
self.assertEqual(len(r1), 1)
r1 = date_range_parser.parse(u'tomorrow late morning', d8_3).get(u'result')
self._compareResults(r1[0], tomorrow_lmorning)
self.assertEqual(len(r1), 1)
r1 = date_range_parser.parse(u'tomorrow brunch', d8_3).get(u'result')
self._compareResults(r1[0], tomorrow_brunch)
self.assertEqual(len(r1), 1)
r1 = date_range_parser.parse(u'tomorrow early lunch', d8_3).get(u'result')
self._compareResults(r1[0], tomorrow_elunch)
self.assertEqual(len(r1), 1)
r1 = date_range_parser.parse(u'tomorrow lunch', d8_3).get(u'result')
self._compareResults(r1[0], tomorrow_lunch)
self.assertEqual(len(r1), 1)
r1 = date_range_parser.parse(u'tomorrow late lunch', d8_3).get(u'result')
self._compareResults(r1[0], tomorrow_llunch)
self.assertEqual(len(r1), 1)
r1 = date_range_parser.parse(u'tomorrow early afternoon', d8_3).get(u'result')
self._compareResults(r1[0], tomorrow_eafternoon)
self.assertEqual(len(r1), 1)
r1 = date_range_parser.parse(u'tomorrow afternoon', d8_3).get(u'result')
self._compareResults(r1[0], tomorrow_afternoon)
self.assertEqual(len(r1), 1)
r1 = date_range_parser.parse(u'tomorrow late afternoon', d8_3).get(u'result')
self._compareResults(r1[0], tomorrow_lafternoon)
self.assertEqual(len(r1), 1)
r1 = date_range_parser.parse(u'tomorrow early night', d8_3).get(u'result')
self._compareResults(r1[0], tomorrow_enight)
self.assertEqual(len(r1), 1)
r1 = date_range_parser.parse(u'tomorrow night', d8_3).get(u'result')
self._compareResults(r1[0], tomorrow_night)
self.assertEqual(len(r1), 1)
r1 = date_range_parser.parse(u'tomorrow late night', d8_3).get(u'result')
self._compareResults(r1[0], tomorrow_lnight)
self.assertEqual(len(r1), 1)
r1 = date_range_parser.parse(u'lunch this week', d8_3).get(u'result')
self._compareResults(r1[0], tomorrow_lunch)
self._compareResults(r1[1], (tomorrow_lunch[0] + timedelta(days=1), tomorrow_lunch[1] + timedelta(days=1)))
self._compareResults(r1[2], (tomorrow_lunch[0] + timedelta(days=2), tomorrow_lunch[1] + timedelta(days=2)))
self._compareResults(r1[3], (tomorrow_lunch[0] + timedelta(days=3), tomorrow_lunch[1] + timedelta(days=3)))
self._compareResults(r1[4], (tomorrow_lunch[0] + timedelta(days=4), tomorrow_lunch[1] + timedelta(days=4)))
self.assertEqual(len(r1), 5)
r1 = date_range_parser.parse(u'lunch this week', d8_3 + timedelta(days=3)).get(u'result')
self._compareResults(r1[0], (tomorrow_lunch[0] + timedelta(days=0+2), tomorrow_lunch[1] + timedelta(days=0+2)))
self._compareResults(r1[1], (tomorrow_lunch[0] + timedelta(days=1+2), tomorrow_lunch[1] + timedelta(days=1+2)))
self._compareResults(r1[2], (tomorrow_lunch[0] + timedelta(days=2+2), tomorrow_lunch[1] + timedelta(days=2+2)))
self.assertEqual(len(r1), 3)
def test_basic_calendar_dates(self):
# Currently on the weekend, test "this week"
monday = self.timezone.localize(datetime.datetime(2014, 8, 4, 0, 0, 0))
tuesday = monday + datetime.timedelta(days=1)
wednesday = tuesday + datetime.timedelta(days=1)
thursday = wednesday + datetime.timedelta(days=1)
friday = thursday + datetime.timedelta(days=1)
saturday = friday + datetime.timedelta(days=1)
sunday = saturday + datetime.timedelta(days=1)
next_monday = sunday + datetime.timedelta(days=1)
last_sunday = monday + datetime.timedelta(days=-1)
# Construct the two part of the last day in this month.
first_day_september = monday.replace(month=9, day=1)
last_day_august = first_day_september + datetime.timedelta(days=-1)
first_day_october = monday.replace(month=10, day=1)
last_day_september = first_day_october + datetime.timedelta(days=-1)
r1 = date_range_parser.parse(u'this week', self.src_time).get(u'result')
# Check that each day showed up.
self._compareResults(r1[0], (monday, tuesday))
self._compareResults(r1[1], (tuesday, wednesday))
self._compareResults(r1[2], (wednesday, thursday))
self._compareResults(r1[3], (thursday, friday))
self._compareResults(r1[4], (friday, saturday))
r1 = date_range_parser.parse(u'in two weeks', self.src_time).get(u'result')
# Check that each day showed up.
self._compareResults(r1[0], (monday+timedelta(days=14), tuesday+timedelta(days=14)))
self._compareResults(r1[1], (tuesday+timedelta(days=14), wednesday+timedelta(days=14)))
self._compareResults(r1[2], (wednesday+timedelta(days=14), thursday+timedelta(days=14)))
self._compareResults(r1[3], (thursday+timedelta(days=14), friday+timedelta(days=14)))
self._compareResults(r1[4], (friday+timedelta(days=14), saturday+timedelta(days=14)))
r1 = date_range_parser.parse(u'in three weeks', self.src_time).get(u'result')
# Check that each day showed up.
self._compareResults(r1[0], (monday+timedelta(days=21), tuesday+timedelta(days=21)))
self._compareResults(r1[1], (tuesday+timedelta(days=21), wednesday+timedelta(days=21)))
self._compareResults(r1[2], (wednesday+timedelta(days=21), thursday+timedelta(days=21)))
self._compareResults(r1[3], (thursday+timedelta(days=21), friday+timedelta(days=21)))
self._compareResults(r1[4], (friday+timedelta(days=21), saturday+timedelta(days=21)))
r2 = date_range_parser.parse(u'next week', self.src_time).get(u'result')
# Still need to fix how we handle this/next weekend.
# Since its Sunday this week and next week should be the same.
#
#self._compareResults(r2[0], (monday, tuesday))
#self._compareResults(r2[1], (tuesday, wednesday))
#self._compareResults(r2[2], (wednesday, thursday))
#self._compareResults(r2[3], (thursday, friday))
#self._compareResults(r2[4], (friday, saturday))
r3 = date_range_parser.parse(u'next weekend', self.src_time).get(u'result')
# Should give us a range of two days.
self._compareResults(r3[0], (saturday, sunday))
self._compareResults(r3[1], (sunday, next_monday))
r4 = date_range_parser.parse(u'this weekend', monday).get(u'result')
# Switch the day src time to monday so this weekend should move forward.
self._compareResults(r4[0], (saturday, sunday))
self._compareResults(r4[1], (sunday, next_monday))
r5 = date_range_parser.parse(u'next weekend', monday).get(u'result')
# With Monday as the src_time next weekend should move even further forward a week.
self._compareResults(r5[0], (saturday+datetime.timedelta(days=7), sunday+datetime.timedelta(days=7)))
self._compareResults(r5[1], (sunday+datetime.timedelta(days=7), next_monday+datetime.timedelta(days=7)))
r6 = date_range_parser.parse(u'this month', self.src_time).get(u'result')
self._compareResults(r6[-1], (last_day_august, first_day_september))
#self.assertEqual(len(r6), first_day_september-1)
r7 = date_range_parser.parse(u'next month', self.src_time).get(u'result')
self._compareResults(r7[-1], (last_day_september, first_day_october))
#self.assertEqual(len(r7), last_day_august.day-1)
r8 = date_range_parser.parse(u'september', self.src_time).get(u'result')
self._compareResults(r8[0], (first_day_september, first_day_september + timedelta(days=1)))
self._compareResults(r8[-1], (last_day_september, first_day_october))
self.assertEqual(len(r8), 30)
def test_absolute_inner_day_modifications(self):
# Sunday 12:00 08/08/2014
d8_3 = self.timezone.localize(datetime.datetime(2014, 8, 3))
d8_4 = d8_3 + datetime.timedelta(days=1)
td_10 = datetime.timedelta(hours=10)
td_14 = datetime.timedelta(hours=14)
# Test applying a date range to a single day.
r1 = date_range_parser.parse(u'tomorrow between 10 - 2 pm', d8_3).get(u'result')
self._compareResults(r1[0], (d8_4 + td_10, d8_4 + td_14))
r1 = date_range_parser.parse(u'tomorrow from 9 - 11', d8_3).get(u'result')
self._compareResults(r1[0], (d8_4 + timedelta(hours=9), d8_4 + timedelta(hours=11)))
r1 = date_range_parser.parse(u'tomorrow from 9 - 1', d8_3).get(u'result')
self._compareResults(r1[0], (d8_4 + timedelta(hours=9), d8_4 + timedelta(hours=13)))
r1 = date_range_parser.parse(u'tomorrow from 12 - 3', d8_3).get(u'result')
self._compareResults(r1[0], (d8_4 + timedelta(hours=12), d8_4 + timedelta(hours=15)))
r1 = date_range_parser.parse(u'tomorrow from 13 - 15', d8_3).get(u'result')
self._compareResults(r1[0], (d8_4 + timedelta(hours=13), d8_4 + timedelta(hours=15)))
r1 = date_range_parser.parse(u'tomorrow between 10 - 2pm', d8_3).get(u'result')
self._compareResults(r1[0], (d8_4 + td_10, d8_4 + td_14))
r1 = date_range_parser.parse(u'tomorrow between 10 - 2PM', d8_3).get(u'result')
self._compareResults(r1[0], (d8_4 + td_10, d8_4 + td_14))
r1 = date_range_parser.parse(u'tomorrow between 10 - 2P.M.', d8_3).get(u'result')
self._compareResults(r1[0], (d8_4 + td_10, d8_4 + td_14))
r1 = date_range_parser.parse(u'tomorrow between 10AM - 2P.M.', d8_3).get(u'result')
self._compareResults(r1[0], (d8_4 + td_10, d8_4 + td_14))
r1 = date_range_parser.parse(u'tomorrow between 10A.M. - 2P.M.', d8_3).get(u'result')
self._compareResults(r1[0], (d8_4 + td_10, d8_4 + td_14))
r1 = date_range_parser.parse(u'tomorrow between 10 A.M. - 2P.M.', d8_3).get(u'result')
self._compareResults(r1[0], (d8_4 + td_10, d8_4 + td_14))
r1 = date_range_parser.parse(u'tomorrow between 10am - 2', d8_3).get(u'result')
self._compareResults(r1[0], (d8_4 + td_10, d8_4 + td_14))
# Test applying an hour range to multiple days.
r2 = date_range_parser.parse(u'this week from 10 am - 2 pm', d8_3).get(u'result')
self._compareResults(r2[0], (d8_4 + td_10, d8_4 + td_14))
self._compareResults(r2[1], (d8_4 + td_10 + datetime.timedelta(days=1), d8_4 + td_14 + datetime.timedelta(days=1)))
self._compareResults(r2[2], (d8_4 + td_10 + datetime.timedelta(days=2), d8_4 + td_14 + datetime.timedelta(days=2)))
self._compareResults(r2[3], (d8_4 + td_10 + datetime.timedelta(days=3), d8_4 + td_14 + datetime.timedelta(days=3)))
self._compareResults(r2[4], (d8_4 + td_10 + datetime.timedelta(days=4), d8_4 + td_14 + datetime.timedelta(days=4)))
# Test applying an hour range to multiple that is shortened by the src_time. src_time = Friday
r3 = date_range_parser.parse(u'this week from 10 am - 2 pm', d8_3 + datetime.timedelta(days=5)).get(u'result')
self._compareResults(r3[0], (d8_4 + td_10 + datetime.timedelta(days=4), d8_4 + td_14 + datetime.timedelta(days=4)))
self.assertEqual(len(r3), 1)
r4 = date_range_parser.parse(u'this week from 10 am - 2 pm', d8_3 + datetime.timedelta(days=4)).get(u'result')
self._compareResults(r4[0], (d8_4 + td_10 + datetime.timedelta(days=3), d8_4 + td_14 + datetime.timedelta(days=3)))
self._compareResults(r4[1], (d8_4 + td_10 + datetime.timedelta(days=4), d8_4 + td_14 + datetime.timedelta(days=4)))
self.assertEqual(len(r4), 2)
def test_basic_absolute_dates(self):
d8_18_sod = self.timezone.localize(datetime.datetime(2014, 8, 18))
d8_18_eod = self.timezone.localize(datetime.datetime(2014, 8, 19))
today_sod = self.timezone.localize(datetime.datetime(2014, 8,3))
tomorrow_sod = self.timezone.localize(datetime.datetime(2014, 8, 4))
tomorrow_eod = self.timezone.localize(datetime.datetime(2014, 8, 5))
monday = tomorrow_sod
tuesday = monday + datetime.timedelta(days=1)
wednesday = tuesday + datetime.timedelta(days=1)
thursday = wednesday + datetime.timedelta(days=1)
next_wednesday = wednesday + datetime.timedelta(days=7)
next_thursday = thursday + datetime.timedelta(days=7)
r1 = date_range_parser.parse(u'8.18', self.src_time).get(u'result')
self._compareResults(r1[0], (d8_18_sod, d8_18_eod))
self.assertEqual(len(r1), 1)
r1 = date_range_parser.parse(u'8/18', self.src_time).get(u'result')
self._compareResults(r1[0], (d8_18_sod, d8_18_eod))
self.assertEqual(len(r1), 1)
r1 = date_range_parser.parse(u'08.18', self.src_time).get(u'result')
self._compareResults(r1[0], (d8_18_sod, d8_18_eod))
self.assertEqual(len(r1), 1)
r1 = date_range_parser.parse(u'08/18', self.src_time).get(u'result')
self._compareResults(r1[0], (d8_18_sod, d8_18_eod))
self.assertEqual(len(r1), 1)
r1 = date_range_parser.parse(u'8.18.14', self.src_time).get(u'result')
self._compareResults(r1[0], (d8_18_sod, d8_18_eod))
self.assertEqual(len(r1), 1)
r1 = date_range_parser.parse(u'08/18/14', self.src_time).get(u'result')
self._compareResults(r1[0], (d8_18_sod, d8_18_eod))
self.assertEqual(len(r1), 1)
r1 = date_range_parser.parse(u'08.18.2014', self.src_time).get(u'result')
self._compareResults(r1[0], (d8_18_sod, d8_18_eod))
self.assertEqual(len(r1), 1)
r1 = date_range_parser.parse(u'08/18/2014', self.src_time).get(u'result')
self._compareResults(r1[0], (d8_18_sod, d8_18_eod))
self.assertEqual(len(r1), 1)
r1 = date_range_parser.parse(u'August 18, 2014', self.src_time).get(u'result')
self._compareResults(r1[0], (d8_18_sod, d8_18_eod))
self.assertEqual(len(r1), 1)
r1 = date_range_parser.parse(u'Aug 18, 2014', self.src_time).get(u'result')
self._compareResults(r1[0], (d8_18_sod, d8_18_eod))
self.assertEqual(len(r1), 1)
r1 = date_range_parser.parse(u'Aug 18', self.src_time).get(u'result')
self._compareResults(r1[0], (d8_18_sod, d8_18_eod))
self.assertEqual(len(r1), 1)
r1 = date_range_parser.parse(u'Aug 18th', self.src_time).get(u'result')
self._compareResults(r1[0], (d8_18_sod, d8_18_eod))
self.assertEqual(len(r1), 1)
r1 = date_range_parser.parse(u'Aug 18th 2014', self.src_time).get(u'result')
self._compareResults(r1[0], (d8_18_sod, d8_18_eod))
self.assertEqual(len(r1), 1)
r1 = date_range_parser.parse(u'on the 18th August 2014', self.src_time).get(u'result')
self._compareResults(r1[0], (d8_18_sod, d8_18_eod))
self.assertEqual(len(r1), 1)
r1 = date_range_parser.parse(u'on the 18 August 2014', self.src_time).get(u'result')
self._compareResults(r1[0], (d8_18_sod, d8_18_eod))
self.assertEqual(len(r1), 1)
r1 = date_range_parser.parse(u'on the 18 Aug 2014', self.src_time).get(u'result')
self._compareResults(r1[0], (d8_18_sod, d8_18_eod))
self.assertEqual(len(r1), 1)
r1 = date_range_parser.parse(u'This is the fourth time I will say Aug 18th 2014', self.src_time).get(u'result')
self._compareResults(r1[0], (d8_18_sod, d8_18_eod))
self.assertEqual(len(r1), 1)
r2 = date_range_parser.parse(u'today', self.src_time).get(u'result')
self._compareResults(r2[0], (today_sod, tomorrow_sod))
self.assertEqual(len(r2), 1)
r3 = date_range_parser.parse(u'tomorrow', self.src_time).get(u'result')
self._compareResults(r3[0], (tomorrow_sod, tomorrow_eod))
self.assertEqual(len(r3), 1)
r3 = date_range_parser.parse(u'wednesday', self.src_time).get(u'result')
self._compareResults(r3[0], (wednesday, thursday))
self.assertEqual(len(r3), 1)
r4 = date_range_parser.parse(u'next wednesday', tomorrow_sod).get(u'result')
self._compareResults(r4[0], (next_wednesday, next_thursday))
self.assertEqual(len(r4), 1)
r5 = date_range_parser.parse('monday', today_sod).get(u'result')
self._compareResults(r5[0], (monday, tuesday ))
self.assertEqual(len(r5), 1)
r5 = date_range_parser.parse('monday', monday).get(u'result')
self._compareResults(r5[0], (monday + timedelta(days=7), tuesday + timedelta(days=7)))
self.assertEqual(len(r5), 1)
r5 = date_range_parser.parse('next monday', tomorrow_sod).get(u'result')
self._compareResults(r5[0], (monday + timedelta(days=7), tuesday + timedelta(days=7)))
self.assertEqual(len(r5), 1)
