def testBadDates(self):
# For example, 1:30am on 27th Oct 2002 happened twice in the US/Eastern
# timezone when the clocks where put back at the end of Daylight Savings
# Time.
# This could be 2002-10-27 01:30:00 EDT-0400
# or 2002-10-27 01:30:00 EST-0500
loc_dt = datetime.datetime(2002, 10, 27, 1, 30, 00)
self.assertRaises(pytz.AmbiguousTimeError, datetime_tz.datetime_tz,
loc_dt, pytz.timezone("US/Eastern"))
# Check we can use is_dst to disambiguate.
loc_dt = datetime.datetime(2002, 10, 27, 1, 30, 00)
dt2 = datetime_tz.datetime_tz(
loc_dt, pytz.timezone("US/Eastern"), is_dst=False)
self.assertEqual(dt2.strftime(FMT), "2002-10-27 01:30:00 EST-0500")
dt1 = datetime_tz.datetime_tz(
loc_dt, pytz.timezone("US/Eastern"), is_dst=True)
self.assertEqual(dt1.strftime(FMT), "2002-10-27 01:30:00 EDT-0400")
# Similarly, 2:30am on 7th April 2002 never happened at all in the
# US/Eastern timezone, as the clock where put forward at 2:00am skipping the
# entire hour.
loc_dt = datetime.datetime(2002, 4, 7, 2, 30, 00)
raiseme = (pytz.AmbiguousTimeError, pytz.NonExistentTimeError)
self.assertRaises(raiseme, datetime_tz.datetime_tz,
loc_dt, pytz.timezone("US/Eastern"))
self.assertRaises(raiseme, datetime_tz.datetime_tz,
loc_dt, pytz.timezone("US/Eastern"), is_dst=True)
self.assertRaises(raiseme, datetime_tz.datetime_tz,
loc_dt, pytz.timezone("US/Eastern"), is_dst=False)
raiseme = (pytz.AmbiguousTimeError, pytz.NonExistentTimeError)
self.assertRaises(raiseme, datetime_tz.datetime_tz,
loc_dt, pytz.timezone("US/Eastern"))
self.assertRaises(raiseme, datetime_tz.datetime_tz,
loc_dt, pytz.timezone("US/Eastern"), is_dst=True)
self.assertRaises(raiseme, datetime_tz.datetime_tz,
loc_dt, pytz.timezone("US/Eastern"), is_dst=False)
# But make sure the cases still work when it"s "now"
@staticmethod
def utcnowmockedt():
return datetime_tz.datetime_tz(2002, 10, 27, 5, 30, tzinfo=pytz.utc)
datetime_tz.localtz_set("US/Eastern")
self.mocked("datetime_tz.datetime_tz.utcnow", utcnowmockedt)
self.assertEqual(datetime_tz.datetime_tz.now().strftime(FMT),
"2002-10-27 01:30:00 EDT-0400")
@staticmethod
def utcnowmockest():
return datetime_tz.datetime_tz(2002, 10, 27, 6, 30, tzinfo=pytz.utc)
datetime_tz.localtz_set("US/Eastern")
self.mocked("datetime_tz.datetime_tz.utcnow", utcnowmockest)
self.assertEqual(datetime_tz.datetime_tz.now().strftime(FMT),
"2002-10-27 01:30:00 EST-0500")
def testPeopleRants(self):
"""This test contains various things which people rant about."""
# Tests some of the pitfuls discussed at
# http://www.enricozini.org/2009/debian/using-python-datetime/
############################################################################
# That's right, the datetime object created by a call to datetime.datetime
# constructor now seems to think that Finland uses the ancient "Helsinki
# Mean Time" which was obsoleted in the 1920s.
#
# Well not anymore!
eurhel = pytz.timezone("Europe/Helsinki")
a = datetime_tz.datetime_tz(2008, 6, 23, 18, 2, 31, 101025, eurhel)
self.assertEqual(repr(a),
"datetime_tz(2008, 6, 23, 18, 2, 31, 101025,"
" tzinfo=<DstTzInfo 'Europe/Helsinki' EEST+3:00:00 DST>)")
# Timezone-aware datetime objects have other bugs: for example, they fail to
# compute Unix timestamps correctly. The following example shows two
# timezone-aware objects that represent the same instant but produce two
# different timestamps.
#
# Well not anymore!
utc = pytz.timezone("UTC")
a = datetime_tz.datetime_tz(2008, 7, 6, 5, 4, 3, tzinfo=utc)
self.assertEqual(str(a), "2008-07-06 05:04:03+00:00")
self.assertEqual(a.totimestamp(), 1215320643.0)
# FIXME(tansell): %s is effected by the TZ environment value.
#self.assertEqual(a.strftime("%s"), "1215284643")
italy = pytz.timezone("Europe/Rome")
b = a.astimezone(italy)
self.assertEqual(str(b), "2008-07-06 07:04:03+02:00")
self.assertEqual(b.totimestamp(), 1215320643.0)
def testBadDates(self):
# For example, 1:30am on 27th Oct 2002 happened twice in the US/Eastern
# timezone when the clocks where put back at the end of Daylight Savings
# Time.
# This could be 2002-10-27 01:30:00 EDT-0400
# or 2002-10-27 01:30:00 EST-0500
loc_dt = datetime.datetime(2002, 10, 27, 1, 30, 00)
self.assertRaises(pytz.AmbiguousTimeError, datetime_tz.datetime_tz,
loc_dt, pytz.timezone("US/Eastern"))
# Check we can use is_dst to disambiguate.
loc_dt = datetime.datetime(2002, 10, 27, 1, 30, 00)
dt2 = datetime_tz.datetime_tz(
loc_dt, pytz.timezone("US/Eastern"), is_dst=False)
self.assertEqual(dt2.strftime(FMT), "2002-10-27 01:30:00 EST-0500")
dt1 = datetime_tz.datetime_tz(
loc_dt, pytz.timezone("US/Eastern"), is_dst=True)
self.assertEqual(dt1.strftime(FMT), "2002-10-27 01:30:00 EDT-0400")
# Similarly, 2:30am on 7th April 2002 never happened at all in the
# US/Eastern timezone, as the clock where put forward at 2:00am skipping the
# entire hour.
loc_dt = datetime.datetime(2002, 4, 7, 2, 30, 00)
raiseme = (pytz.AmbiguousTimeError, pytz.NonExistentTimeError)
self.assertRaises(raiseme, datetime_tz.datetime_tz,
loc_dt, pytz.timezone("US/Eastern"))
self.assertRaises(raiseme, datetime_tz.datetime_tz,
loc_dt, pytz.timezone("US/Eastern"), is_dst=True)
self.assertRaises(raiseme, datetime_tz.datetime_tz,
loc_dt, pytz.timezone("US/Eastern"), is_dst=False)
raiseme = (pytz.AmbiguousTimeError, pytz.NonExistentTimeError)
self.assertRaises(raiseme, datetime_tz.datetime_tz,
loc_dt, pytz.timezone("US/Eastern"))
self.assertRaises(raiseme, datetime_tz.datetime_tz,
loc_dt, pytz.timezone("US/Eastern"), is_dst=True)
self.assertRaises(raiseme, datetime_tz.datetime_tz,
loc_dt, pytz.timezone("US/Eastern"), is_dst=False)
# But make sure the cases still work when it"s "now"
@staticmethod
def utcnowmockedt():
return datetime_tz.datetime_tz(2002, 10, 27, 5, 30, tzinfo=pytz.utc)
datetime_tz.localtz_set("US/Eastern")
self.mocked("datetime_tz.datetime_tz.utcnow", utcnowmockedt)
self.assertEqual(datetime_tz.datetime_tz.now().strftime(FMT),
"2002-10-27 01:30:00 EDT-0400")
@staticmethod
def utcnowmockest():
return datetime_tz.datetime_tz(2002, 10, 27, 6, 30, tzinfo=pytz.utc)
datetime_tz.localtz_set("US/Eastern")
self.mocked("datetime_tz.datetime_tz.utcnow", utcnowmockest)
self.assertEqual(datetime_tz.datetime_tz.now().strftime(FMT),
"2002-10-27 01:30:00 EST-0500")
def testPeopleRants(self):
"""This test contains various things which people rant about."""
# Tests some of the pitfuls discussed at
# http://www.enricozini.org/2009/debian/using-python-datetime/
############################################################################
# That's right, the datetime object created by a call to datetime.datetime
# constructor now seems to think that Finland uses the ancient "Helsinki
# Mean Time" which was obsoleted in the 1920s.
#
# Well not anymore!
eurhel = pytz.timezone("Europe/Helsinki")
a = datetime_tz.datetime_tz(2008, 6, 23, 18, 2, 31, 101025, eurhel)
self.assertEqual(repr(a),
"datetime_tz(2008, 6, 23, 18, 2, 31, 101025,"
" tzinfo=<DstTzInfo 'Europe/Helsinki' EEST+3:00:00 DST>)")
# Timezone-aware datetime objects have other bugs: for example, they fail to
# compute Unix timestamps correctly. The following example shows two
# timezone-aware objects that represent the same instant but produce two
# different timestamps.
#
# Well not anymore!
utc = pytz.timezone("UTC")
a = datetime_tz.datetime_tz(2008, 7, 6, 5, 4, 3, tzinfo=utc)
self.assertEqual(str(a), "2008-07-06 05:04:03+00:00")
self.assertEqual(a.totimestamp(), 1215320643.0)
# FIXME(tansell): %s is effected by the TZ environment value.
#self.assertEqual(a.strftime("%s"), "1215284643")
italy = pytz.timezone("Europe/Rome")
b = a.astimezone(italy)
self.assertEqual(str(b), "2008-07-06 07:04:03+02:00")
self.assertEqual(b.totimestamp(), 1215320643.0)
def testAroundDst(self):
# Testing going backwards into daylight savings
utc_dt = datetime_tz.datetime_tz(2002, 10, 27, 6, 10, 0, tzinfo=pytz.utc)
loc_dt = utc_dt.astimezone(pytz.timezone("US/Eastern"))
self.assertEqual(loc_dt.strftime(FMT), "2002-10-27 01:10:00 EST-0500")
before = loc_dt - datetime_tz.timedelta(minutes=10)
self.assertEqual(before.strftime(FMT), "2002-10-27 01:00:00 EST-0500")
before = loc_dt - datetime_tz.timedelta(minutes=20)
self.assertEqual(before.strftime(FMT), "2002-10-27 01:50:00 EDT-0400")
after = loc_dt + datetime_tz.timedelta(minutes=10)
self.assertEqual(after.strftime(FMT), "2002-10-27 01:20:00 EST-0500")
# Testing going forwards out of daylight savings
utc_dt = datetime_tz.datetime_tz(2002, 10, 27, 5, 50, 0, tzinfo=pytz.utc)
loc_dt = utc_dt.astimezone(pytz.timezone("US/Eastern"))
self.assertEqual(loc_dt.strftime(FMT), "2002-10-27 01:50:00 EDT-0400")
after = loc_dt + datetime_tz.timedelta(minutes=10)
self.assertEqual(after.strftime(FMT), "2002-10-27 01:00:00 EST-0500")
after = loc_dt + datetime_tz.timedelta(minutes=20)
self.assertEqual(after.strftime(FMT), "2002-10-27 01:10:00 EST-0500")
before = loc_dt - datetime_tz.timedelta(minutes=10)
self.assertEqual(before.strftime(FMT), "2002-10-27 01:40:00 EDT-0400")
# Test going backwards out of daylight savings
utc_dt = datetime_tz.datetime_tz(2002, 4, 7, 7, 10, 00, tzinfo=pytz.utc)
loc_dt = utc_dt.astimezone(pytz.timezone("US/Eastern"))
self.assertEqual(loc_dt.strftime(FMT), "2002-04-07 03:10:00 EDT-0400")
before = loc_dt - datetime_tz.timedelta(minutes=10)
self.assertEqual(before.strftime(FMT), "2002-04-07 03:00:00 EDT-0400")
before = loc_dt - datetime_tz.timedelta(minutes=20)
self.assertEqual(before.strftime(FMT), "2002-04-07 01:50:00 EST-0500")
after = loc_dt + datetime_tz.timedelta(minutes=10)
self.assertEqual(after.strftime(FMT), "2002-04-07 03:20:00 EDT-0400")
# Test going forwards into daylight savings
utc_dt = datetime_tz.datetime_tz(2002, 4, 7, 6, 50, 00, tzinfo=pytz.utc)
loc_dt = utc_dt.astimezone(pytz.timezone("US/Eastern"))
self.assertEqual(loc_dt.strftime(FMT), "2002-04-07 01:50:00 EST-0500")
after = loc_dt + datetime_tz.timedelta(minutes=10)
self.assertEqual(after.strftime(FMT), "2002-04-07 03:00:00 EDT-0400")
after = loc_dt + datetime_tz.timedelta(minutes=20)
self.assertEqual(after.strftime(FMT), "2002-04-07 03:10:00 EDT-0400")
before = loc_dt - datetime_tz.timedelta(minutes=10)
self.assertEqual(before.strftime(FMT), "2002-04-07 01:40:00 EST-0500")
def testAroundDst(self):
# Testing going backwards into daylight savings
utc_dt = datetime_tz.datetime_tz(2002, 10, 27, 6, 10, 0, tzinfo=pytz.utc)
loc_dt = utc_dt.astimezone(pytz.timezone("US/Eastern"))
self.assertEqual(loc_dt.strftime(FMT), "2002-10-27 01:10:00 EST-0500")
before = loc_dt - datetime_tz.timedelta(minutes=10)
self.assertEqual(before.strftime(FMT), "2002-10-27 01:00:00 EST-0500")
before = loc_dt - datetime_tz.timedelta(minutes=20)
self.assertEqual(before.strftime(FMT), "2002-10-27 01:50:00 EDT-0400")
after = loc_dt + datetime_tz.timedelta(minutes=10)
self.assertEqual(after.strftime(FMT), "2002-10-27 01:20:00 EST-0500")
# Testing going forwards out of daylight savings
utc_dt = datetime_tz.datetime_tz(2002, 10, 27, 5, 50, 0, tzinfo=pytz.utc)
loc_dt = utc_dt.astimezone(pytz.timezone("US/Eastern"))
self.assertEqual(loc_dt.strftime(FMT), "2002-10-27 01:50:00 EDT-0400")
after = loc_dt + datetime_tz.timedelta(minutes=10)
self.assertEqual(after.strftime(FMT), "2002-10-27 01:00:00 EST-0500")
after = loc_dt + datetime_tz.timedelta(minutes=20)
self.assertEqual(after.strftime(FMT), "2002-10-27 01:10:00 EST-0500")
before = loc_dt - datetime_tz.timedelta(minutes=10)
self.assertEqual(before.strftime(FMT), "2002-10-27 01:40:00 EDT-0400")
# Test going backwards out of daylight savings
utc_dt = datetime_tz.datetime_tz(2002, 4, 7, 7, 10, 00, tzinfo=pytz.utc)
loc_dt = utc_dt.astimezone(pytz.timezone("US/Eastern"))
self.assertEqual(loc_dt.strftime(FMT), "2002-04-07 03:10:00 EDT-0400")
before = loc_dt - datetime_tz.timedelta(minutes=10)
self.assertEqual(before.strftime(FMT), "2002-04-07 03:00:00 EDT-0400")
before = loc_dt - datetime_tz.timedelta(minutes=20)
self.assertEqual(before.strftime(FMT), "2002-04-07 01:50:00 EST-0500")
after = loc_dt + datetime_tz.timedelta(minutes=10)
self.assertEqual(after.strftime(FMT), "2002-04-07 03:20:00 EDT-0400")
# Test going forwards into daylight savings
utc_dt = datetime_tz.datetime_tz(2002, 4, 7, 6, 50, 00, tzinfo=pytz.utc)
loc_dt = utc_dt.astimezone(pytz.timezone("US/Eastern"))
self.assertEqual(loc_dt.strftime(FMT), "2002-04-07 01:50:00 EST-0500")
after = loc_dt + datetime_tz.timedelta(minutes=10)
self.assertEqual(after.strftime(FMT), "2002-04-07 03:00:00 EDT-0400")
after = loc_dt + datetime_tz.timedelta(minutes=20)
self.assertEqual(after.strftime(FMT), "2002-04-07 03:10:00 EDT-0400")
before = loc_dt - datetime_tz.timedelta(minutes=10)
self.assertEqual(before.strftime(FMT), "2002-04-07 01:40:00 EST-0500")
def test_asset_dicts_equal_naive_datetimes(self):
d1 = {
1:
datetime_tz.datetime_tz(
2019,
2,
8,
8,
0,
0,
tzinfo=pytz.timezone('Africa/Johannesburg'))
}
d2 = {1: datetime_tz.datetime_tz(2019, 2, 8, 6, 0, 0, tzinfo=pytz.utc)}
DictUtils.assert_dicts_equal(d1, d2, True)
def testConvert(self):
d = datetime_tz.datetime_tz(2009, 5, 1, 16, 12, 10)
d_datetime = d.asdatetime()
self.assert_(isinstance(d_datetime, datetime.datetime))
self.assert_(not isinstance(d_datetime, datetime_tz.datetime_tz))
self.assertEqual(d_datetime, datetime.datetime(2009, 5, 1, 16, 12, 10))
d_date = d.asdate()
self.assert_(isinstance(d_date, datetime.date))
self.assert_(not isinstance(d_date, datetime.datetime))
self.assertEqual(d_date, datetime.date(2009, 5, 1))
def testConvert(self):
d = datetime_tz.datetime_tz(2009, 5, 1, 16, 12, 10)
d_datetime = d.asdatetime()
self.assert_(isinstance(d_datetime, datetime.datetime))
self.assert_(not isinstance(d_datetime, datetime_tz.datetime_tz))
self.assertEqual(d_datetime, datetime.datetime(2009, 5, 1, 16, 12, 10))
d_date = d.asdate()
self.assert_(isinstance(d_date, datetime.date))
self.assert_(not isinstance(d_date, datetime.datetime))
self.assertEqual(d_date, datetime.date(2009, 5, 1))
def timetuple_to_datetime(t):
"""Convert a timetuple to a datetime object.
"""
return datetime_tz.datetime_tz(*(t[:6]))
def utcnowmockest(): return datetime_tz.datetime_tz(2002, 10, 27, 6, 30, tzinfo=pytz.utc)
def utcnowmockest(): return datetime_tz.datetime_tz(2002, 10, 27, 6, 30, tzinfo=pytz.utc)
def testCreation(self):
# Create with the local timezone
datetime_tz.localtz_set(pytz.utc)
d0 = datetime_tz.datetime_tz(2008, 10, 1)
self.assert_(isinstance(d0, datetime_tz.datetime_tz))
self.assertEqual(d0.tzinfo, pytz.utc)
# Creation with string timezone
d1 = datetime_tz.datetime_tz(2008, 10, 1, tzinfo="UTC")
self.assert_(isinstance(d1, datetime_tz.datetime_tz))
self.assertEqual(d1.tzinfo, pytz.utc)
# Creation with tzinfo object
d2 = datetime_tz.datetime_tz(2008, 10, 1, tzinfo=pytz.utc)
self.assert_(isinstance(d2, datetime_tz.datetime_tz))
self.assertEqual(d1.tzinfo, pytz.utc)
# Creation from a datetime_tz object
d3 = datetime_tz.datetime_tz(d1)
self.assert_(isinstance(d3, datetime_tz.datetime_tz))
self.assertEqual(d1.tzinfo, d3.tzinfo)
# Creation from a datetime object
d4 = datetime.datetime.now()
d4 = pytz.timezone("Australia/Sydney").localize(d4)
d5 = datetime_tz.datetime_tz(d4)
self.assert_(isinstance(d3, datetime_tz.datetime_tz))
self.assertEqual(d4.tzinfo, d5.tzinfo)
# Creation from a naive datetime object not in DST
d6 = datetime.datetime(2008, 12, 5)
try:
d7 = datetime_tz.datetime_tz(d6)
self.fail("Was able to create from a naive datetime without a timezone")
except TypeError:
pass
d7 = datetime_tz.datetime_tz(d6, "US/Pacific")
self.assert_(isinstance(d7, datetime_tz.datetime_tz))
self.assertEqual(d7.tzinfo.zone, "US/Pacific")
self.assertEqual(d7.tzinfo._dst, datetime.timedelta(0))
# Creation from a naive datetime object in DST
d6 = datetime.datetime(2008, 7, 13)
try:
d7 = datetime_tz.datetime_tz(d6)
self.fail("Was able to create from a naive datetime without a timezone")
except TypeError:
pass
d7 = datetime_tz.datetime_tz(d6, "US/Pacific")
self.assert_(isinstance(d7, datetime_tz.datetime_tz))
self.assertEqual(d7.tzinfo.zone, "US/Pacific")
self.assertEqual(d7.tzinfo._dst, datetime.timedelta(0, 3600))
datetime_tz.localtz_set(pytz.utc)
d0 = datetime_tz.datetime_tz(2008, 10, 1)
self.assert_(isinstance(d0, datetime_tz.datetime_tz))
self.assertEqual(d0.tzinfo, pytz.utc)
d1 = datetime_tz.datetime_tz(d1)
self.assert_(isinstance(d1, datetime_tz.datetime_tz))
self.assertEqual(d1.tzinfo, pytz.utc)
self.assertEqual(d0, d1)
self.assertFalse(d0 is d1)
def main(argv):
conference_schedules = defaultdict(dict)
# Download the schedule details for each channel and group into
# conferences.
for channel in CONFIG.groups():
if channel == 'example':
continue
config = CONFIG.config(channel)
if 'schedule' not in config or not config['schedule']:
sys.stderr.write("Channel %s doesn't have a schedule.\n" % channel)
continue
tzinfo = None
if config['schedule-timezone']:
tzinfo = pytz.timezone(config['schedule-timezone'])
channel_schedule = get_schedule_json(config['schedule'], channel,
tzinfo)
channel_schedule_list = []
for e in channel_schedule:
channel_schedule_list.append(e['fields'])
conference = config['group']
if config['conference']:
conference = config['conference']
schedule = []
for item in channel_schedule_list:
if item['name'] in ("miniconf schedules to be determined", ):
continue
data = {
'start': item['start'],
'end': item['end'],
'title': item['name'].strip(),
'abstract': item['description'],
'url': item['public_url'],
}
if not data['title']:
continue
schedule.append(data)
schedule.sort(key=lambda i: i['start'])
conference_schedules[conference][channel] = schedule
# Fill in day start / day end events for each conference day.
# (We need to work in the schedule's timezone for this to work properly.)
for conference in conference_schedules:
# First earliest and latest event in a conference.
all_events = []
for channel_schedule in conference_schedules[conference].values():
all_events.extend(channel_schedule)
all_events.sort(key=lambda i: i['start'])
starting_event = all_events[0]
ending_event = all_events[-1]
for channel in conference_schedules[conference]:
oldevents = conference_schedules[conference][channel]
config = CONFIG.config(channel)
if not config['schedule-timezone']:
sys.stderr.write(
"%s has not timezone, can't add conference day events\n" %
channel)
continue
tzinfo = pytz.timezone(config['schedule-timezone'])
# Group events onto days
perday_events = defaultdict(list)
for event in oldevents:
perday_events[event['end'].astimezone(tzinfo).date()].append(
event)
# Remove any days which are 100% via another schedule.
for day in list(perday_events.keys()):
for event in perday_events[day]:
if not event.get('via', False):
break
else:
# All generated
del perday_events[day]
# Add in any missing days
startdate = datetime_tz.combine(
starting_event['start'].astimezone(tzinfo).date(),
datetime_tz.min.time(), tzinfo)
enddate = datetime_tz.combine(
ending_event['start'].astimezone(tzinfo).date(),
datetime_tz.min.time(), tzinfo)
for day in dt_iterate.days(startdate, enddate):
if day.date() not in perday_events:
day_skipped_event = {
'start':
datetime_tz.combine(day, datetime_tz.min.time(),
tzinfo).astimezone(pytz.utc),
'end':
datetime_tz.combine(day, datetime_tz.max.time(),
tzinfo).astimezone(pytz.utc),
'title':
'Nothing in %s today' % config['title'],
'abstract':
'',
'generated':
True,
}
perday_events[day.date()].append(day_skipped_event)
# Add start of day / end of day events
for day, events in perday_events.items():
if day > startdate.date() and events[0]['start'].astimezone(
tzinfo).time() != datetime_tz.min.time():
events.insert(
0, {
'start':
datetime_tz.combine(day, datetime_tz.min.time(),
tzinfo).astimezone(pytz.utc),
'end':
events[0]['start'],
'title':
'Not yet started in %s' % config['title'],
'abstract':
'',
'generated':
True,
})
if day < enddate.date() and events[-1]['end'].astimezone(
tzinfo).time() != datetime_tz.max.time():
events.append({
'start':
events[-1]['end'],
'end':
datetime_tz.combine(day, datetime_tz.max.time(),
tzinfo).astimezone(pytz.utc),
'title':
'Finished for the day in %s' % config['title'],
'abstract':
'',
'generated':
True,
})
# Create a before conference start event.
before_event = {
'start':
datetime_tz(datetime_tz.min.asdatetime(naive=True),
tzinfo).astimezone(pytz.utc),
'end':
starting_event['start'],
'title':
'%s not yet started' % conference,
'abstract':
'',
'generated':
True,
}
# Create an after conference end event.
after_event = {
'start':
ending_event['end'],
'end':
datetime_tz(datetime_tz.max.asdatetime(naive=True),
tzinfo).astimezone(pytz.utc),
'title':
'%s finished :(' % conference,
'abstract':
'',
'generated':
True,
}
# Put everything back together
newevents = [before_event]
for day in sorted(perday_events.keys()):
newevents.extend(perday_events[day])
newevents.append(after_event)
conference_schedules[conference][channel] = newevents
# Fill in any gaps
for conference in conference_schedules:
for channel in conference_schedules[conference]:
oldevents = conference_schedules[conference][channel]
newevents = [oldevents.pop(0)]
conference_schedules[conference][channel] = newevents
while len(oldevents) > 0:
delta = oldevents[0]['start'] - newevents[-1]['end']
if delta.seconds > (5 * 60):
unknown_event = {
'start': newevents[-1]['end'],
'end': oldevents[0]['start'],
'abstract': '',
'generated': True,
}
unknown_event['title'] = '%i minute break' % (
(unknown_event['end'] - unknown_event['start']).seconds
/ 60)
newevents.append(unknown_event)
newevents.append(oldevents.pop(0))
# Add guid to each event
for conference in conference_schedules:
for channel in conference_schedules[conference]:
for item in conference_schedules[conference][channel]:
if 'guid' not in item:
item['guid'] = hashlib.md5(str(item['start']) +
channel).hexdigest()
print_schedule(conference_schedules)
output_data = {}
for conference in conference_schedules:
for channel in conference_schedules[conference]:
output_data[channel] = conference_schedules[conference][channel]
out = StringIO.StringIO()
pprint.pprint(output_data, stream=out)
print """\
from datetime_tz import datetime_tz
import pytz
data = \\"""
print out.getvalue()
def testCreation(self):
# Create with the local timezone
datetime_tz.localtz_set(pytz.utc)
d0 = datetime_tz.datetime_tz(2008, 10, 1)
self.assert_(isinstance(d0, datetime_tz.datetime_tz))
self.assertEqual(d0.tzinfo, pytz.utc)
# Creation with string timezone
d1 = datetime_tz.datetime_tz(2008, 10, 1, tzinfo="UTC")
self.assert_(isinstance(d1, datetime_tz.datetime_tz))
self.assertEqual(d1.tzinfo, pytz.utc)
# Creation with tzinfo object
d2 = datetime_tz.datetime_tz(2008, 10, 1, tzinfo=pytz.utc)
self.assert_(isinstance(d2, datetime_tz.datetime_tz))
self.assertEqual(d1.tzinfo, pytz.utc)
# Creation from a datetime_tz object
d3 = datetime_tz.datetime_tz(d1)
self.assert_(isinstance(d3, datetime_tz.datetime_tz))
self.assertEqual(d1.tzinfo, d3.tzinfo)
# Creation from a datetime object
d4 = datetime.datetime.now()
d4 = pytz.timezone("Australia/Sydney").localize(d4)
d5 = datetime_tz.datetime_tz(d4)
self.assert_(isinstance(d3, datetime_tz.datetime_tz))
self.assertEqual(d4.tzinfo, d5.tzinfo)
# Creation from a naive datetime object not in DST
d6 = datetime.datetime(2008, 12, 5)
try:
d7 = datetime_tz.datetime_tz(d6)
self.fail("Was able to create from a naive datetime without a timezone")
except TypeError:
pass
d7 = datetime_tz.datetime_tz(d6, "US/Pacific")
self.assert_(isinstance(d7, datetime_tz.datetime_tz))
self.assertEqual(d7.tzinfo.zone, "US/Pacific")
self.assertEqual(d7.tzinfo._dst, datetime.timedelta(0))
# Creation from a naive datetime object in DST
d6 = datetime.datetime(2008, 7, 13)
try:
d7 = datetime_tz.datetime_tz(d6)
self.fail("Was able to create from a naive datetime without a timezone")
except TypeError:
pass
d7 = datetime_tz.datetime_tz(d6, "US/Pacific")
self.assert_(isinstance(d7, datetime_tz.datetime_tz))
self.assertEqual(d7.tzinfo.zone, "US/Pacific")
self.assertEqual(d7.tzinfo._dst, datetime.timedelta(0, 3600))
datetime_tz.localtz_set(pytz.utc)
d0 = datetime_tz.datetime_tz(2008, 10, 1)
self.assert_(isinstance(d0, datetime_tz.datetime_tz))
self.assertEqual(d0.tzinfo, pytz.utc)
d1 = datetime_tz.datetime_tz(d1)
self.assert_(isinstance(d1, datetime_tz.datetime_tz))
self.assertEqual(d1.tzinfo, pytz.utc)
self.assertEqual(d0, d1)
self.assertFalse(d0 is d1)
def testSmartParse(self):
datetime_tz.localtz_set("Australia/Sydney")
tz = pytz.timezone("US/Pacific")
now = datetime_tz.datetime_tz(2008, 12, 5, tzinfo=tz)
tommorrow = now+datetime.timedelta(days=1)
@staticmethod
def now_fake(tzinfo):
if tz is tzinfo:
return now
else:
assert False
self.mocked("datetime_tz.datetime_tz.now", now_fake)
d = datetime_tz.datetime_tz.smartparse("now", tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(d, now)
self.assertEqual(d.tzinfo.zone, tz.zone)
d = datetime_tz.datetime_tz.smartparse("today", tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(d, now)
self.assertEqual(d.tzinfo.zone, tz.zone)
# test that it's not case sensitive
d = datetime_tz.datetime_tz.smartparse("ToDay", tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(d, now)
self.assertEqual(d.tzinfo.zone, tz.zone)
d = datetime_tz.datetime_tz.smartparse("NOW", tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(d, now)
self.assertEqual(d.tzinfo.zone, tz.zone)
d = datetime_tz.datetime_tz.smartparse("yesterday", tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(d, now-datetime.timedelta(days=1))
self.assertEqual(d.tzinfo.zone, tz.zone)
d = datetime_tz.datetime_tz.smartparse("tommorrow", tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(d, tommorrow)
self.assertEqual(d.tzinfo.zone, tz.zone)
d = datetime_tz.datetime_tz.smartparse("a second ago", tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(d, now-datetime.timedelta(seconds=1))
self.assertEqual(d.tzinfo.zone, tz.zone)
d = datetime_tz.datetime_tz.smartparse("1 second ago", tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(d, now-datetime.timedelta(seconds=1))
self.assertEqual(d.tzinfo.zone, tz.zone)
d = datetime_tz.datetime_tz.smartparse("2 seconds ago", tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(d, now-datetime.timedelta(seconds=2))
self.assertEqual(d.tzinfo.zone, tz.zone)
d = datetime_tz.datetime_tz.smartparse("1 minute ago", tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(d, now-datetime.timedelta(minutes=1))
self.assertEqual(d.tzinfo.zone, tz.zone)
d = datetime_tz.datetime_tz.smartparse("2 minutes ago", tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(d, now-datetime.timedelta(minutes=2))
self.assertEqual(d.tzinfo.zone, tz.zone)
d = datetime_tz.datetime_tz.smartparse("1 hour ago", tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(d, now-datetime.timedelta(hours=1))
self.assertEqual(d.tzinfo.zone, tz.zone)
d = datetime_tz.datetime_tz.smartparse("2 hours ago", tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(d, now-datetime.timedelta(hours=2))
self.assertEqual(d.tzinfo.zone, tz.zone)
d = datetime_tz.datetime_tz.smartparse("2 days ago", tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(d, now-datetime.timedelta(days=2))
self.assertEqual(d.tzinfo.zone, tz.zone)
d = datetime_tz.datetime_tz.smartparse("2 days 5 hours ago", tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(d, now-datetime.timedelta(days=2, hours=5))
self.assertEqual(d.tzinfo.zone, tz.zone)
d = datetime_tz.datetime_tz.smartparse("2 days and a hour ago", tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(d, now-datetime.timedelta(days=2, hours=1))
self.assertEqual(d.tzinfo.zone, tz.zone)
d = datetime_tz.datetime_tz.smartparse("4 daYs AND A SECond aGO", tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(d, now-datetime.timedelta(days=4, seconds=1))
self.assertEqual(d.tzinfo.zone, tz.zone)
d = datetime_tz.datetime_tz.smartparse("1 day and a hour ago", tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(d, now-datetime.timedelta(days=1, hours=1))
self.assertEqual(d.tzinfo.zone, tz.zone)
d = datetime_tz.datetime_tz.smartparse("an hour and a day ago", tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(d, now-datetime.timedelta(days=1, hours=1))
self.assertEqual(d.tzinfo.zone, tz.zone)
d = datetime_tz.datetime_tz.smartparse("1d 2h ago", tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(d, now-datetime.timedelta(days=1, hours=2))
self.assertEqual(d.tzinfo.zone, tz.zone)
d = datetime_tz.datetime_tz.smartparse("2h5m32s ago", tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(d, now-datetime.timedelta(hours=2, minutes=5, seconds=32))
self.assertEqual(d.tzinfo.zone, tz.zone)
d = datetime_tz.datetime_tz.smartparse("1y 2 month ago", tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(d, now-dateutil.relativedelta.relativedelta(
years=1, months=2))
self.assertEqual(d.tzinfo.zone, tz.zone)
d = datetime_tz.datetime_tz.smartparse("2 months and 3m ago", tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(d, now-dateutil.relativedelta.relativedelta(
months=2, minutes=3))
self.assertEqual(d.tzinfo.zone, tz.zone)
d = datetime_tz.datetime_tz.smartparse("3m4months1y ago", tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(d, now-dateutil.relativedelta.relativedelta(
years=1, months=4, minutes=3))
self.assertEqual(d.tzinfo.zone, tz.zone)
d = datetime_tz.datetime_tz.smartparse("3m4months and 1y ago", tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(d, now-dateutil.relativedelta.relativedelta(
years=1, months=4, minutes=3))
self.assertEqual(d.tzinfo.zone, tz.zone)
self.assertRaises(ValueError,
datetime_tz.datetime_tz.smartparse,
"5 billion years ago", tz)
self.assertRaises(ValueError,
datetime_tz.datetime_tz.smartparse,
"5 ago", tz)
# FIXME: These below should actually test the equivalence
d = datetime_tz.datetime_tz.smartparse("start of today", tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(d, now.replace(hour=0, minute=0, second=0, microsecond=0))
self.assertEqual(d.tzinfo.zone, tz.zone)
d = datetime_tz.datetime_tz.smartparse("start of tommorrow", tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(
d, tommorrow.replace(hour=0, minute=0, second=0, microsecond=0))
self.assertEqual(d.tzinfo.zone, tz.zone)
d = datetime_tz.datetime_tz.smartparse("start of yesterday", tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(d.tzinfo.zone, tz.zone)
d = datetime_tz.datetime_tz.smartparse("end of today", tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(d.tzinfo.zone, tz.zone)
d = datetime_tz.datetime_tz.smartparse("end of tommorrow", tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(
d, tommorrow.replace(
hour=23, minute=59, second=59, microsecond=999999))
self.assertEqual(d.tzinfo.zone, tz.zone)
d = datetime_tz.datetime_tz.smartparse("end of yesterday", tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(d.tzinfo.zone, tz.zone)
# FIXME: These above should actually test the equivalence
self.mocked.tearDown()
# Test datetime string with timezone information,
# also provide timezone argument
d = datetime_tz.datetime_tz.smartparse("2009-11-09 23:00:00-05:00", tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(str(d), "2009-11-09 23:00:00-05:00")
self.assertEqual(d.tzinfo, pytz.FixedOffset(-300))
d = datetime_tz.datetime_tz.smartparse("2009-11-09 23:00:00+0800", tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(str(d), "2009-11-09 23:00:00+08:00")
self.assertEqual(d.tzinfo, pytz.FixedOffset(480))
d = datetime_tz.datetime_tz.smartparse("2009-11-09 23:00:00 EST", tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(str(d), "2009-11-09 23:00:00-05:00")
self.assertEqual(d.tzinfo, pytz.timezone("US/Eastern"))
d = datetime_tz.datetime_tz.smartparse("2009-11-09 23:00:00 EST-05:00", tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(str(d), "2009-11-09 23:00:00-05:00")
self.assertEqual(d.tzinfo, pytz.timezone("US/Eastern"))
d = datetime_tz.datetime_tz.smartparse("Mon Nov 09 23:00:00 EST 2009", tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(str(d), "2009-11-09 23:00:00-05:00")
self.assertEqual(d.tzinfo, pytz.timezone("US/Eastern"))
# Test datetime string with timezone information,
# no more timezone argument
d = datetime_tz.datetime_tz.smartparse("2009-11-09 23:00:00-05:00")
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(str(d), "2009-11-09 23:00:00-05:00")
self.assertEqual(d.tzinfo, pytz.FixedOffset(-300))
d = datetime_tz.datetime_tz.smartparse("2009-11-09 23:00:00+0800")
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(str(d), "2009-11-09 23:00:00+08:00")
self.assertEqual(d.tzinfo, pytz.FixedOffset(480))
d = datetime_tz.datetime_tz.smartparse("2009-11-09 23:00:00 EST")
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(str(d), "2009-11-09 23:00:00-05:00")
self.assertEqual(d.tzinfo, pytz.timezone("US/Eastern"))
d = datetime_tz.datetime_tz.smartparse("2009-11-09 23:00:00 EST-05:00")
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(str(d), "2009-11-09 23:00:00-05:00")
self.assertEqual(d.tzinfo, pytz.timezone("US/Eastern"))
d = datetime_tz.datetime_tz.smartparse("Mon Nov 09 23:00:00 EST 2009")
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(str(d), "2009-11-09 23:00:00-05:00")
self.assertEqual(d.tzinfo, pytz.timezone("US/Eastern"))
# UTC, nice and easy
d = datetime_tz.datetime_tz.smartparse("Tue Jul 03 06:00:01 UTC 2010")
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(str(d), "2010-07-03 06:00:01+00:00")
self.assertEqual(d.tzinfo, pytz.timezone("UTC"))
# Try Pacific standard time
d = datetime_tz.datetime_tz.smartparse("2002-10-27 01:20:00 EST")
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(str(d), "2002-10-27 01:20:00-05:00")
self.assertEqual(d.tzinfo.zone, pytz.timezone("US/Eastern").zone)
d = datetime_tz.datetime_tz.smartparse("2002-10-27 01:20:00 EDT")
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(str(d), "2002-10-27 01:20:00-04:00")
self.assertEqual(d.tzinfo.zone, pytz.timezone("US/Eastern").zone)
# Using Oslon timezones means you end up with ambigious dates.
# 2002-10-27 01:30:00 US/Eastern
# could be either,
# 2002-10-27 01:30:00 EDT-0400
# 2002-10-27 01:30:00 EST-0500
try:
d = datetime_tz.datetime_tz.smartparse(
"Tue Jul 03 06:00:01 US/Pacific 2010")
self.assert_(False)
except ValueError:
pass
# Make sure we get exceptions when invalid timezones are used.
try:
d = datetime_tz.datetime_tz.smartparse("Mon Nov 09 23:00:00 Random 2009")
self.assert_(False)
except ValueError:
pass
try:
d = datetime_tz.datetime_tz.smartparse("Mon Nov 09 23:00:00 XXX 2009")
self.assert_(False)
except ValueError:
pass
###########################################################################
toparse = datetime_tz.datetime_tz(2008, 06, 5)
d = datetime_tz.datetime_tz.smartparse(toparse.strftime("%Y/%m/%d"))
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(d, toparse)
d = datetime_tz.datetime_tz.smartparse(toparse.strftime("%Y-%m-%d"))
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(d, toparse)
d = datetime_tz.datetime_tz.smartparse(toparse.strftime("%Y%m%d"))
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(d, toparse)
d = datetime_tz.datetime_tz.smartparse(
toparse.strftime("start of %d, %B %Y"))
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(
d, toparse.replace(hour=0, minute=0, second=0, microsecond=0))
toparse = datetime_tz.datetime_tz(2008, 12, 5, tzinfo=tz)
d = datetime_tz.datetime_tz.smartparse(toparse.strftime("%Y/%m/%d"), tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(d.tzinfo.zone, tz.zone)
self.assertEqual(d, toparse)
d = datetime_tz.datetime_tz.smartparse(toparse.strftime("%Y-%m-%d"), tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(d.tzinfo.zone, tz.zone)
self.assertEqual(d, toparse)
d = datetime_tz.datetime_tz.smartparse(toparse.strftime("%Y%m%d"), tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(d.tzinfo.zone, tz.zone)
self.assertEqual(d, toparse)
d = datetime_tz.datetime_tz.smartparse(
toparse.strftime("start of %d, %B %Y"), tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(d.tzinfo.zone, tz.zone)
self.assertEqual(
d, toparse.replace(hour=0, minute=0, second=0, microsecond=0))
simple_od = DictUtils.ordereddict()
simple_od[99] = [('a', 1), ('b', 2)]
simple_od[1] = [('c', 3), ('d', 4)]
simple_od[7] = [('e', 5), ('f', 6)]
class OrderedDictInABox(object):
def __init__(self, message, ordered_dict):
self.message = message
self.od = ordered_dict
inner_od = DictUtils.ordereddict()
inner_od['first'] = datetime_tz.datetime_tz(1979, 8, 8, 16)
inner_od['second'] = {'a': 1, 'b': 2, 'c': 3}
inner_od['third'] = OrderedDictInABox(
'Here it is', DictUtils.ordereddict([(0, 'Here'), (1, 'it'), (2, 'is')]))
inner_od['fourth'] = OrderedDictInABox(
'Here it is - remix',
DictUtils.ordereddict([(1, 'it'), (2, 'is'), (0, 'Here')]))
inner_od['fifth'] = OrderedDictInABox(
'Here it is - remix 2 feat. ?',
DictUtils.ordereddict([(2, 'is'), (1, 'it'), (0, 'Here?')]))
complex_od = DictUtils.ordereddict()
complex_od[2] = [('a', 1), ('b', 2)]
complex_od[0] = inner_od
complex_od[1] = None
def testSmartParse(self):
datetime_tz.localtz_set("Australia/Sydney")
tz = pytz.timezone("US/Pacific")
now = datetime_tz.datetime_tz(2008, 12, 5, tzinfo=tz)
tomorrow = now+datetime.timedelta(days=1)
@staticmethod
def now_fake(tzinfo):
if tz is tzinfo:
return now
else:
assert False
self.mocked("datetime_tz.datetime_tz.now", now_fake)
d = datetime_tz.datetime_tz.smartparse("now", tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(d, now)
self.assertEqual(d.tzinfo.zone, tz.zone)
d = datetime_tz.datetime_tz.smartparse("today", tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(d, now)
self.assertEqual(d.tzinfo.zone, tz.zone)
# test that it's not case sensitive
d = datetime_tz.datetime_tz.smartparse("ToDay", tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(d, now)
self.assertEqual(d.tzinfo.zone, tz.zone)
d = datetime_tz.datetime_tz.smartparse("NOW", tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(d, now)
self.assertEqual(d.tzinfo.zone, tz.zone)
d = datetime_tz.datetime_tz.smartparse("yesterday", tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(d, now-datetime.timedelta(days=1))
self.assertEqual(d.tzinfo.zone, tz.zone)
d = datetime_tz.datetime_tz.smartparse("tomorrow", tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(d, tomorrow)
self.assertEqual(d.tzinfo.zone, tz.zone)
d = datetime_tz.datetime_tz.smartparse("a second ago", tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(d, now-datetime.timedelta(seconds=1))
self.assertEqual(d.tzinfo.zone, tz.zone)
d = datetime_tz.datetime_tz.smartparse("1 second ago", tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(d, now-datetime.timedelta(seconds=1))
self.assertEqual(d.tzinfo.zone, tz.zone)
d = datetime_tz.datetime_tz.smartparse("2 seconds ago", tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(d, now-datetime.timedelta(seconds=2))
self.assertEqual(d.tzinfo.zone, tz.zone)
d = datetime_tz.datetime_tz.smartparse("1 minute ago", tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(d, now-datetime.timedelta(minutes=1))
self.assertEqual(d.tzinfo.zone, tz.zone)
d = datetime_tz.datetime_tz.smartparse("2 minutes ago", tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(d, now-datetime.timedelta(minutes=2))
self.assertEqual(d.tzinfo.zone, tz.zone)
d = datetime_tz.datetime_tz.smartparse("1 hour ago", tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(d, now-datetime.timedelta(hours=1))
self.assertEqual(d.tzinfo.zone, tz.zone)
d = datetime_tz.datetime_tz.smartparse("2 hours ago", tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(d, now-datetime.timedelta(hours=2))
self.assertEqual(d.tzinfo.zone, tz.zone)
d = datetime_tz.datetime_tz.smartparse("2 days ago", tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(d, now-datetime.timedelta(days=2))
self.assertEqual(d.tzinfo.zone, tz.zone)
d = datetime_tz.datetime_tz.smartparse("2 days 5 hours ago", tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(d, now-datetime.timedelta(days=2, hours=5))
self.assertEqual(d.tzinfo.zone, tz.zone)
d = datetime_tz.datetime_tz.smartparse("2 days and a hour ago", tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(d, now-datetime.timedelta(days=2, hours=1))
self.assertEqual(d.tzinfo.zone, tz.zone)
d = datetime_tz.datetime_tz.smartparse("4 daYs AND A SECond aGO", tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(d, now-datetime.timedelta(days=4, seconds=1))
self.assertEqual(d.tzinfo.zone, tz.zone)
d = datetime_tz.datetime_tz.smartparse("1 day and a hour ago", tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(d, now-datetime.timedelta(days=1, hours=1))
self.assertEqual(d.tzinfo.zone, tz.zone)
d = datetime_tz.datetime_tz.smartparse("an hour and a day ago", tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(d, now-datetime.timedelta(days=1, hours=1))
self.assertEqual(d.tzinfo.zone, tz.zone)
d = datetime_tz.datetime_tz.smartparse("1d 2h ago", tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(d, now-datetime.timedelta(days=1, hours=2))
self.assertEqual(d.tzinfo.zone, tz.zone)
d = datetime_tz.datetime_tz.smartparse("2h5m32s ago", tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(d, now-datetime.timedelta(hours=2, minutes=5, seconds=32))
self.assertEqual(d.tzinfo.zone, tz.zone)
d = datetime_tz.datetime_tz.smartparse("1y 2 month ago", tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(d, now-dateutil.relativedelta.relativedelta(
years=1, months=2))
self.assertEqual(d.tzinfo.zone, tz.zone)
d = datetime_tz.datetime_tz.smartparse("2 months and 3m ago", tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(d, now-dateutil.relativedelta.relativedelta(
months=2, minutes=3))
self.assertEqual(d.tzinfo.zone, tz.zone)
d = datetime_tz.datetime_tz.smartparse("3m4months1y ago", tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(d, now-dateutil.relativedelta.relativedelta(
years=1, months=4, minutes=3))
self.assertEqual(d.tzinfo.zone, tz.zone)
d = datetime_tz.datetime_tz.smartparse("3m4months and 1y ago", tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(d, now-dateutil.relativedelta.relativedelta(
years=1, months=4, minutes=3))
self.assertEqual(d.tzinfo.zone, tz.zone)
self.assertRaises(ValueError,
datetime_tz.datetime_tz.smartparse,
"5 billion years ago", tz)
self.assertRaises(ValueError,
datetime_tz.datetime_tz.smartparse,
"5 ago", tz)
# FIXME: These below should actually test the equivalence
d = datetime_tz.datetime_tz.smartparse("start of today", tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(d, now.replace(hour=0, minute=0, second=0, microsecond=0))
self.assertEqual(d.tzinfo.zone, tz.zone)
d = datetime_tz.datetime_tz.smartparse("start of tomorrow", tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(
d, tomorrow.replace(hour=0, minute=0, second=0, microsecond=0))
self.assertEqual(d.tzinfo.zone, tz.zone)
d = datetime_tz.datetime_tz.smartparse("start of yesterday", tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(d.tzinfo.zone, tz.zone)
d = datetime_tz.datetime_tz.smartparse("end of today", tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(d.tzinfo.zone, tz.zone)
d = datetime_tz.datetime_tz.smartparse("end of tomorrow", tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(
d, tomorrow.replace(
hour=23, minute=59, second=59, microsecond=999999))
self.assertEqual(d.tzinfo.zone, tz.zone)
d = datetime_tz.datetime_tz.smartparse("end of yesterday", tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(d.tzinfo.zone, tz.zone)
# FIXME: These above should actually test the equivalence
self.mocked.tearDown()
# Test datetime string with timezone information,
# also provide timezone argument
d = datetime_tz.datetime_tz.smartparse("2009-11-09 23:00:00-05:00", tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(str(d), "2009-11-09 23:00:00-05:00")
self.assertEqual(d.tzinfo, pytz.FixedOffset(-300))
d = datetime_tz.datetime_tz.smartparse("2009-11-09 23:00:00+0800", tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(str(d), "2009-11-09 23:00:00+08:00")
self.assertEqual(d.tzinfo, pytz.FixedOffset(480))
d = datetime_tz.datetime_tz.smartparse("2009-11-09 23:00:00 EST", tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(str(d), "2009-11-09 23:00:00-05:00")
self.assertEqual(d.tzinfo, pytz.timezone("US/Eastern"))
d = datetime_tz.datetime_tz.smartparse("2009-11-09 23:00:00 EST-05:00", tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(str(d), "2009-11-09 23:00:00-05:00")
self.assertEqual(d.tzinfo, pytz.timezone("US/Eastern"))
d = datetime_tz.datetime_tz.smartparse("Mon Nov 09 23:00:00 EST 2009", tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(str(d), "2009-11-09 23:00:00-05:00")
self.assertEqual(d.tzinfo, pytz.timezone("US/Eastern"))
# Test datetime string with timezone information,
# no more timezone argument
d = datetime_tz.datetime_tz.smartparse("2009-11-09 23:00:00-05:00")
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(str(d), "2009-11-09 23:00:00-05:00")
self.assertEqual(d.tzinfo, pytz.FixedOffset(-300))
d = datetime_tz.datetime_tz.smartparse("2009-11-09 23:00:00+0800")
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(str(d), "2009-11-09 23:00:00+08:00")
self.assertEqual(d.tzinfo, pytz.FixedOffset(480))
d = datetime_tz.datetime_tz.smartparse("2009-11-09 23:00:00 EST")
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(str(d), "2009-11-09 23:00:00-05:00")
self.assertEqual(d.tzinfo, pytz.timezone("US/Eastern"))
d = datetime_tz.datetime_tz.smartparse("2009-11-09 23:00:00 EST-05:00")
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(str(d), "2009-11-09 23:00:00-05:00")
self.assertEqual(d.tzinfo, pytz.timezone("US/Eastern"))
d = datetime_tz.datetime_tz.smartparse("Mon Nov 09 23:00:00 EST 2009")
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(str(d), "2009-11-09 23:00:00-05:00")
self.assertEqual(d.tzinfo, pytz.timezone("US/Eastern"))
# UTC, nice and easy
d = datetime_tz.datetime_tz.smartparse("Tue Jul 03 06:00:01 UTC 2010")
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(str(d), "2010-07-03 06:00:01+00:00")
self.assertEqual(d.tzinfo, pytz.timezone("UTC"))
# Try Pacific standard time
d = datetime_tz.datetime_tz.smartparse("2002-10-27 01:20:00 EST")
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(str(d), "2002-10-27 01:20:00-05:00")
self.assertEqual(d.tzinfo.zone, pytz.timezone("US/Eastern").zone)
d = datetime_tz.datetime_tz.smartparse("2002-10-27 01:20:00 EDT")
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(str(d), "2002-10-27 01:20:00-04:00")
self.assertEqual(d.tzinfo.zone, pytz.timezone("US/Eastern").zone)
# Using Oslon timezones means you end up with ambigious dates.
# 2002-10-27 01:30:00 US/Eastern
# could be either,
# 2002-10-27 01:30:00 EDT-0400
# 2002-10-27 01:30:00 EST-0500
try:
d = datetime_tz.datetime_tz.smartparse(
"Tue Jul 03 06:00:01 US/Pacific 2010")
self.assert_(False)
except ValueError:
pass
# Make sure we get exceptions when invalid timezones are used.
try:
d = datetime_tz.datetime_tz.smartparse("Mon Nov 09 23:00:00 Random 2009")
self.assert_(False)
except ValueError:
pass
try:
d = datetime_tz.datetime_tz.smartparse("Mon Nov 09 23:00:00 XXX 2009")
self.assert_(False)
except ValueError:
pass
###########################################################################
toparse = datetime_tz.datetime_tz(2008, 6, 5)
d = datetime_tz.datetime_tz.smartparse(toparse.strftime("%Y/%m/%d"))
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(d, toparse)
d = datetime_tz.datetime_tz.smartparse(toparse.strftime("%Y-%m-%d"))
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(d, toparse)
d = datetime_tz.datetime_tz.smartparse(toparse.strftime("%Y%m%d"))
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(d, toparse)
d = datetime_tz.datetime_tz.smartparse(
toparse.strftime("start of %d, %B %Y"))
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(
d, toparse.replace(hour=0, minute=0, second=0, microsecond=0))
toparse = datetime_tz.datetime_tz(2008, 12, 5, tzinfo=tz)
d = datetime_tz.datetime_tz.smartparse(toparse.strftime("%Y/%m/%d"), tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(d.tzinfo.zone, tz.zone)
self.assertEqual(d, toparse)
d = datetime_tz.datetime_tz.smartparse(toparse.strftime("%Y-%m-%d"), tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(d.tzinfo.zone, tz.zone)
self.assertEqual(d, toparse)
d = datetime_tz.datetime_tz.smartparse(toparse.strftime("%Y%m%d"), tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(d.tzinfo.zone, tz.zone)
self.assertEqual(d, toparse)
d = datetime_tz.datetime_tz.smartparse(
toparse.strftime("start of %d, %B %Y"), tz)
self.assert_(isinstance(d, datetime_tz.datetime_tz))
self.assertEqual(d.tzinfo.zone, tz.zone)
self.assertEqual(
d, toparse.replace(hour=0, minute=0, second=0, microsecond=0))
def testReplace(self):
# Testing normal replace
dt = datetime_tz.datetime_tz(
2010, 3, 10, 17, 23, 26, 871430, "US/Pacific")
replaced = dt.replace(hour=0, minute=0, second=0, microsecond=1)
result = datetime_tz.datetime_tz(
2010, 3, 10, 0, 0, 0, 1, "US/Pacific")
self.assertEqual(result, replaced)
replaced = dt.replace(hour=0, minute=0, second=0, microsecond=0)
result = datetime_tz.datetime_tz(
2010, 3, 10, 0, 0, 0, 0, "US/Pacific")
self.assertEqual(result, replaced)
# Test replacing across daylight savings boundary
dt = datetime_tz.datetime_tz(
2010, 3, 14, 17, 23, 26, 871430, "US/Pacific")
replaced = dt.replace(hour=0, minute=0, second=0, microsecond=1)
result = datetime_tz.datetime_tz(
2010, 3, 14, 0, 0, 0, 1, "US/Pacific")
self.assertEqual(result, replaced)
replaced = dt.replace(hour=0, minute=0, second=0, microsecond=0)
result = datetime_tz.datetime_tz(
2010, 3, 14, 0, 0, 0, 0, "US/Pacific")
self.assertEqual(result, replaced)
# Test starting outside of DST
utc_dt = datetime_tz.datetime_tz(2002, 10, 27, 6, 10, 0, tzinfo=pytz.utc)
loc_dt = utc_dt.astimezone(pytz.timezone("US/Eastern"))
self.assertEqual(loc_dt.strftime(FMT), "2002-10-27 01:10:00 EST-0500")
# Since we don't start off in DST, so a replace should try and keep us out
# of DST
assert not loc_dt.is_dst
replace = loc_dt.replace(hour=1)
self.assertEqual(replace.strftime(FMT), "2002-10-27 01:10:00 EST-0500")
replace = loc_dt.replace(is_dst=False)
self.assertEqual(replace.strftime(FMT), "2002-10-27 01:10:00 EST-0500")
replace = loc_dt.replace(minute=50, second=0, microsecond=0)
self.assertEqual(replace.strftime(FMT), "2002-10-27 01:50:00 EST-0500")
# Unless we are also replacing the DST flag
replace = loc_dt.replace(hour=1, is_dst=True)
self.assertEqual(replace.strftime(FMT), "2002-10-27 01:10:00 EDT-0400")
replace = loc_dt.replace(is_dst=True)
self.assertEqual(replace.strftime(FMT), "2002-10-27 01:10:00 EDT-0400")
replace = loc_dt.replace(minute=50, second=0, microsecond=0, is_dst=True)
self.assertEqual(replace.strftime(FMT), "2002-10-27 01:50:00 EDT-0400")
# But if we go too far, replace should still do the right thing
replace = loc_dt.replace(day=26)
self.assertEqual(replace.strftime(FMT), "2002-10-26 01:10:00 EDT-0400")
replace = loc_dt.replace(day=28)
self.assertEqual(replace.strftime(FMT), "2002-10-28 01:10:00 EST-0500")
# FIXME(tansell): Make these test work.
#self.assertRaises(pytz.NonExistentTimeError, loc_dt.replace,
# day=26, is_dst=False)
#self.assertRaises(pytz.NonExistentTimeError, loc_dt.replace,
# day=28, is_dst=True)
# Testing starting in DST
utc_dt = datetime_tz.datetime_tz(2002, 4, 7, 7, 10, 00, tzinfo=pytz.utc)
loc_dt = utc_dt.astimezone(pytz.timezone("US/Eastern"))
self.assertEqual(loc_dt.strftime(FMT), "2002-04-07 03:10:00 EDT-0400")
# Since we start in DST, so a replace should try and keep us in DST.
assert loc_dt.is_dst
replace = loc_dt.replace(minute=0, second=0, microsecond=0)
self.assertEqual(replace.strftime(FMT), "2002-04-07 03:00:00 EDT-0400")
# 2:30 doesn't actually exist
self.assertRaises(pytz.NonExistentTimeError, loc_dt.replace,
hour=2, minute=30, second=0, microsecond=0)
def testReplace(self):
# Testing normal replace
dt = datetime_tz.datetime_tz(
2010, 3, 10, 17, 23, 26, 871430, "US/Pacific")
replaced = dt.replace(hour=0, minute=0, second=0, microsecond=1)
result = datetime_tz.datetime_tz(
2010, 3, 10, 0, 0, 0, 1, "US/Pacific")
self.assertEqual(result, replaced)
replaced = dt.replace(hour=0, minute=0, second=0, microsecond=0)
result = datetime_tz.datetime_tz(
2010, 3, 10, 0, 0, 0, 0, "US/Pacific")
self.assertEqual(result, replaced)
# Test replacing across daylight savings boundary
dt = datetime_tz.datetime_tz(
2010, 3, 14, 17, 23, 26, 871430, "US/Pacific")
replaced = dt.replace(hour=0, minute=0, second=0, microsecond=1)
result = datetime_tz.datetime_tz(
2010, 3, 14, 0, 0, 0, 1, "US/Pacific")
self.assertEqual(result, replaced)
replaced = dt.replace(hour=0, minute=0, second=0, microsecond=0)
result = datetime_tz.datetime_tz(
2010, 3, 14, 0, 0, 0, 0, "US/Pacific")
self.assertEqual(result, replaced)
# Test starting outside of DST
utc_dt = datetime_tz.datetime_tz(2002, 10, 27, 6, 10, 0, tzinfo=pytz.utc)
loc_dt = utc_dt.astimezone(pytz.timezone("US/Eastern"))
self.assertEqual(loc_dt.strftime(FMT), "2002-10-27 01:10:00 EST-0500")
# Since we don't start off in DST, so a replace should try and keep us out
# of DST
assert not loc_dt.is_dst
replace = loc_dt.replace(hour=1)
self.assertEqual(replace.strftime(FMT), "2002-10-27 01:10:00 EST-0500")
replace = loc_dt.replace(is_dst=False)
self.assertEqual(replace.strftime(FMT), "2002-10-27 01:10:00 EST-0500")
replace = loc_dt.replace(minute=50, second=0, microsecond=0)
self.assertEqual(replace.strftime(FMT), "2002-10-27 01:50:00 EST-0500")
# Unless we are also replacing the DST flag
replace = loc_dt.replace(hour=1, is_dst=True)
self.assertEqual(replace.strftime(FMT), "2002-10-27 01:10:00 EDT-0400")
replace = loc_dt.replace(is_dst=True)
self.assertEqual(replace.strftime(FMT), "2002-10-27 01:10:00 EDT-0400")
replace = loc_dt.replace(minute=50, second=0, microsecond=0, is_dst=True)
self.assertEqual(replace.strftime(FMT), "2002-10-27 01:50:00 EDT-0400")
# But if we go too far, replace should still do the right thing
replace = loc_dt.replace(day=26)
self.assertEqual(replace.strftime(FMT), "2002-10-26 01:10:00 EDT-0400")
replace = loc_dt.replace(day=28)
self.assertEqual(replace.strftime(FMT), "2002-10-28 01:10:00 EST-0500")
# FIXME(tansell): Make these test work.
#self.assertRaises(pytz.NonExistentTimeError, loc_dt.replace,
# day=26, is_dst=False)
#self.assertRaises(pytz.NonExistentTimeError, loc_dt.replace,
# day=28, is_dst=True)
# Testing starting in DST
utc_dt = datetime_tz.datetime_tz(2002, 4, 7, 7, 10, 00, tzinfo=pytz.utc)
loc_dt = utc_dt.astimezone(pytz.timezone("US/Eastern"))
self.assertEqual(loc_dt.strftime(FMT), "2002-04-07 03:10:00 EDT-0400")
# Since we start in DST, so a replace should try and keep us in DST.
assert loc_dt.is_dst
replace = loc_dt.replace(minute=0, second=0, microsecond=0)
self.assertEqual(replace.strftime(FMT), "2002-04-07 03:00:00 EDT-0400")
# 2:30 doesn't actually exist
self.assertRaises(pytz.NonExistentTimeError, loc_dt.replace,
hour=2, minute=30, second=0, microsecond=0)
def main(argv):
if CONFIG['config']['schedule-format']:
if CONFIG['config']['schedule-format'] == 'pycon':
return os.system('python pycon2internal.py')
if CONFIG['config']['schedule-format'] == 'veyepar':
return os.system('python veyepar2internal.py')
if CONFIG['config']['schedule-format'] == 'symposion':
return os.system('python symposion2internal.py')
conference_schedules = defaultdict(dict)
# Download the schedule details for each channel and group into
# conferences.
for channel in CONFIG.groups():
config = CONFIG.config(channel)
if 'schedule' not in config or not config['schedule']:
sys.stderr.write("Channel %s doesn't have a schedule.\n" % channel)
continue
tzinfo = None
if config['schedule-timezone']:
tzinfo = pytz.timezone(config['schedule-timezone'])
channel_schedule = get_schedule_json(config['schedule'], tzinfo)
conference = config['group']
if config['conference']:
conference = config['conference']
schedule = []
for item in channel_schedule:
if 'Title' not in item or not item['Title'] or item[
'Title'] in BLACKLISTED_EVENTS:
continue
if item['Room Name'] != config['schedule-key'] and item[
'Room Name'] != config['schedule-see-also']:
# Event is not in this room
continue
data = {
'start': item['Start'],
'title': item['Title'].strip(),
'abstract': item['Description'],
'url': None,
}
if 'End' in item:
data['end'] = item['End']
elif 'Duration' in item:
data['end'] = data['start'] + parse_pytimedelta(
item['Duration'])
else:
sys.stderr.write(
'Event %r does not have a End time or Duration, dropped.\n'
% item['Title'])
continue
if 'URL' in item:
data['url'] = item['URL']
schedule.append(data)
schedule.sort(key=lambda i: i['start'])
conference_schedules[conference][channel] = schedule
# Fill in day start / day end events for each conference day.
# (We need to work in the schedule's timezone for this to work properly.)
for conference in conference_schedules:
# First earliest and latest event in a conference.
all_events = []
for channel_schedule in conference_schedules[conference].values():
all_events.extend(channel_schedule)
all_events.sort(key=lambda i: i['start'])
if len(all_events) == 0:
# No events this day
sys.stderr.write("There are no events in %r\n" % (conference, ))
continue
starting_event = all_events[0]
ending_event = all_events[-1]
for channel in conference_schedules[conference]:
oldevents = conference_schedules[conference][channel]
config = CONFIG.config(channel)
if not config['schedule-timezone']:
sys.stderr.write(
"%s has not timezone, can't add conference day events\n" %
channel)
continue
tzinfo = pytz.timezone(config['schedule-timezone'])
# Group events onto days
perday_events = defaultdict(list)
for event in oldevents:
perday_events[event['end'].astimezone(tzinfo).date()].append(
event)
# Remove any days which are 100% via another schedule.
for day in list(perday_events.keys()):
for event in perday_events[day]:
if not event.get('via', False):
break
else:
# All generated
del perday_events[day]
# Add in any missing days
startdate = datetime_tz.combine(
starting_event['start'].astimezone(tzinfo).date(),
datetime_tz.min.time(), tzinfo)
enddate = datetime_tz.combine(
ending_event['start'].astimezone(tzinfo).date(),
datetime_tz.min.time(), tzinfo)
for day in dt_iterate.days(startdate, enddate):
if day.date() not in perday_events:
day_skipped_event = {
'start':
datetime_tz.combine(day, datetime_tz.min.time(),
tzinfo).astimezone(pytz.utc),
'end':
datetime_tz.combine(day, datetime_tz.max.time(),
tzinfo).astimezone(pytz.utc),
'title':
'Nothing in %s today' % config['title'],
'abstract':
'',
'generated':
True,
}
perday_events[day.date()].append(day_skipped_event)
# Add start of day / end of day events
for day, events in perday_events.items():
if day > startdate.date() and events[0]['start'].astimezone(
tzinfo).time() != datetime_tz.min.time():
events.insert(
0, {
'start':
datetime_tz.combine(day, datetime_tz.min.time(),
tzinfo).astimezone(pytz.utc),
'end':
events[0]['start'],
'title':
'Not yet started in %s' % config['title'],
'abstract':
'',
'generated':
True,
})
if day < enddate.date() and events[-1]['end'].astimezone(
tzinfo).time() != datetime_tz.max.time():
events.append({
'start':
events[-1]['end'],
'end':
datetime_tz.combine(day, datetime_tz.max.time(),
tzinfo).astimezone(pytz.utc),
'title':
'Finished for the day in %s' % config['title'],
'abstract':
'',
'generated':
True,
})
# Create a before conference start event.
before_event = {
'start':
datetime_tz(datetime_tz.min.asdatetime(naive=True),
tzinfo).astimezone(pytz.utc),
'end':
starting_event['start'],
'title':
'%s not yet started' % conference,
'abstract':
'',
'generated':
True,
}
# Create an after conference end event.
after_event = {
'start':
ending_event['end'],
'end':
datetime_tz(datetime_tz.max.asdatetime(naive=True),
tzinfo).astimezone(pytz.utc),
'title':
'%s finished :(' % conference,
'abstract':
'',
'generated':
True,
}
# Put everything back together
newevents = [before_event]
for day in sorted(perday_events.keys()):
newevents.extend(perday_events[day])
newevents.append(after_event)
conference_schedules[conference][channel] = newevents
# Fill in any gaps
for conference in conference_schedules:
for channel in conference_schedules[conference]:
oldevents = conference_schedules[conference][channel]
if len(oldevents) == 0:
# No events on day
continue
newevents = [oldevents.pop(0)]
conference_schedules[conference][channel] = newevents
while len(oldevents) > 0:
delta = oldevents[0]['start'] - newevents[-1]['end']
if delta.seconds > (5 * 60):
unknown_event = {
'start': newevents[-1]['end'],
'end': oldevents[0]['start'],
'abstract': '',
'generated': True,
}
unknown_event['title'] = '%i minute break' % (
(unknown_event['end'] - unknown_event['start']).seconds
/ 60)
newevents.append(unknown_event)
newevents.append(oldevents.pop(0))
# Add guid to each event
for conference in conference_schedules:
for channel in conference_schedules[conference]:
for item in conference_schedules[conference][channel]:
if 'guid' not in item:
item['guid'] = hashlib.md5(str(item['start']) +
channel).hexdigest()
print_schedule(conference_schedules)
output_data = {}
for conference in conference_schedules:
for channel in conference_schedules[conference]:
output_data[channel] = conference_schedules[conference][channel]
out = StringIO.StringIO()
pprint.pprint(output_data, stream=out)
print """\
from datetime_tz import datetime_tz
import pytz
data = \\"""
print out.getvalue()
def main(argv):
conference_schedules = defaultdict(dict)
# Download the schedule details for each channel and group into
# conferences.
for channel in CONFIG.groups():
config = CONFIG.config(channel)
if 'schedule' not in config or not config['schedule']:
sys.stderr.write("Channel %s doesn't have a schedule.\n" % channel)
continue
tzinfo = None
if config['schedule-timezone']:
tzinfo = pytz.timezone(config['schedule-timezone'])
channel_schedule = get_schedule_json(config['schedule'], tzinfo)
if config['schedule-key'] not in channel_schedule:
raise IOError()
conference = config['group']
if config['conference']:
conference = config['conference']
schedule = []
for schedule_key in [config['schedule-key']] + config['schedule-see-also']:
for item in channel_schedule[schedule_key]:
if item['title'] in ("miniconf schedules to be determined",):
continue
data = {
'start': item['start'],
'end': item['end'],
'title': item['title'],
'abstract': item['abstract'],
'url': '',
}
if 'url' in item:
data['url'] = item['url']
if schedule_key == 'uncatered':
data['via'] = schedule_key
data['title'] = "Lunch Break"
elif schedule_key != config['schedule-key']:
data['via'] = schedule_key
data['title'] = "Move to %s for %s" % (schedule_key, item['title'])
schedule.append(data)
schedule.sort(key=lambda i: i['start'])
conference_schedules[conference][channel] = schedule
# Fill in day start / day end events for each conference day.
# (We need to work in the schedule's timezone for this to work properly.)
for conference in conference_schedules:
# First earliest and latest event in a conference.
all_events = []
for channel_schedule in conference_schedules[conference].values():
all_events.extend(channel_schedule)
all_events.sort(key=lambda i: i['start'])
starting_event = all_events[0]
ending_event = all_events[-1]
for channel in conference_schedules[conference]:
oldevents = conference_schedules[conference][channel]
config = CONFIG.config(channel)
if not config['schedule-timezone']:
sys.stderr.write("%s has not timezone, can't add conference day events\n" % channel)
continue
tzinfo = pytz.timezone(config['schedule-timezone'])
# Group events onto days
perday_events = defaultdict(list)
for event in oldevents:
perday_events[event['end'].astimezone(tzinfo).date()].append(event)
# Remove any days which are 100% via another schedule.
for day in list(perday_events.keys()):
for event in perday_events[day]:
if not event.get('via', False):
break
else:
# All generated
del perday_events[day]
# Add in any missing days
startdate = datetime_tz.combine(
starting_event['start'].astimezone(tzinfo).date(),
datetime_tz.min.time(),
tzinfo)
enddate = datetime_tz.combine(
ending_event['start'].astimezone(tzinfo).date(),
datetime_tz.min.time(),
tzinfo)
for day in dt_iterate.days(startdate, enddate):
if day.date() not in perday_events:
day_skipped_event = {
'start': datetime_tz.combine(day, datetime_tz.min.time(), tzinfo).astimezone(pytz.utc),
'end': datetime_tz.combine(day, datetime_tz.max.time(), tzinfo).astimezone(pytz.utc),
'title': '<i>Nothing in %s today</i>' % config['title'],
'abstract': '',
'generated': True,
}
perday_events[day.date()].append(day_skipped_event)
# Add start of day / end of day events
for day, events in perday_events.items():
if day > startdate.date() and events[0]['start'].astimezone(tzinfo).time() != datetime_tz.min.time():
events.insert(0, {
'start': datetime_tz.combine(day, datetime_tz.min.time(), tzinfo).astimezone(pytz.utc),
'end': events[0]['start'],
'title': '<i>Not yet started in %s</i>' % config['title'],
'abstract': '',
'generated': True,
})
if day < enddate.date() and events[-1]['end'].astimezone(tzinfo).time() != datetime_tz.max.time():
events.append({
'start': events[-1]['end'],
'end': datetime_tz.combine(day, datetime_tz.max.time(), tzinfo).astimezone(pytz.utc),
'title': '<i>Finished for the day in %s</i>' % config['title'],
'abstract': '',
'generated': True,
})
# Create a before conference start event.
before_event = {
'start': datetime_tz(datetime_tz.min.asdatetime(naive=True), tzinfo).astimezone(pytz.utc),
'end': starting_event['start'],
'title': '<i>%s not yet started</i>' % conference,
'abstract': '',
'generated': True,
}
# Create an after conference end event.
after_event = {
'start': ending_event['end'],
'end': datetime_tz(datetime_tz.max.asdatetime(naive=True), tzinfo).astimezone(pytz.utc),
'title': '<i>%s finished :(</i>' % conference,
'abstract': '',
'generated': True,
}
# Put everything back together
newevents = [before_event]
for day in sorted(perday_events.keys()):
newevents.extend(perday_events[day])
newevents.append(after_event)
conference_schedules[conference][channel] = newevents
# Fill in any gaps
for conference in conference_schedules:
for channel in conference_schedules[conference]:
oldevents = conference_schedules[conference][channel]
newevents = [oldevents.pop(0)]
conference_schedules[conference][channel] = newevents
while len(oldevents) > 0:
delta = oldevents[0]['start'] - newevents[-1]['end']
if delta.seconds > (5*60):
unknown_event = {
'start': newevents[-1]['end'],
'end': oldevents[0]['start'],
'abstract': '',
'generated': True,
}
unknown_event['title'] = '<i>%i minute break</i>' % ((unknown_event['end'] - unknown_event['start']).seconds/60)
newevents.append(unknown_event)
newevents.append(oldevents.pop(0))
# Add guid to each event
for conference in conference_schedules:
for channel in conference_schedules[conference]:
for item in conference_schedules[conference][channel]:
if 'guid' not in item:
item['guid'] = hashlib.md5(str(item['start'])+channel).hexdigest()
print_schedule(conference_schedules)
output_data = {}
for conference in conference_schedules:
for channel in conference_schedules[conference]:
output_data[channel] = conference_schedules[conference][channel]
out = StringIO.StringIO()
pprint.pprint(output_data, stream=out)
print """\
from datetime_tz import datetime_tz
import pytz
data = \\"""
print out.getvalue()
def main(argv):
if CONFIG['config']['schedule-format']:
if CONFIG['config']['schedule-format'] == 'pycon':
return os.system('python pycon2internal.py')
if CONFIG['config']['schedule-format'] == 'veyepar':
return os.system('python veyepar2internal.py')
if CONFIG['config']['schedule-format'] == 'symposion':
return os.system('python symposion2internal.py')
conference_schedules = defaultdict(dict)
# Download the schedule details for each channel and group into
# conferences.
for channel in CONFIG.groups():
config = CONFIG.config(channel)
if 'schedule' not in config or not config['schedule']:
sys.stderr.write("Channel %s doesn't have a schedule.\n" % channel)
continue
tzinfo = None
if config['schedule-timezone']:
tzinfo = pytz.timezone(config['schedule-timezone'])
channel_schedule = get_schedule_json(config['schedule'], tzinfo)
conference = config['group']
if config['conference']:
conference = config['conference']
schedule = []
for item in channel_schedule:
if 'Title' not in item or not item['Title'] or item['Title'] in BLACKLISTED_EVENTS:
continue
if item['Room Name'] != config['schedule-key'] and item['Room Name'] != config['schedule-see-also']:
# Event is not in this room
continue
data = {
'start': item['Start'],
'title': item['Title'].strip(),
'abstract': item['Description'],
'url': None,
}
if 'End' in item:
data['end'] = item['End']
elif 'Duration' in item:
data['end'] = data['start'] + parse_pytimedelta(item['Duration'])
else:
sys.stderr.write('Event %r does not have a End time or Duration, dropped.\n' % item['Title'])
continue
if 'URL' in item:
data['url'] = item['URL']
schedule.append(data)
schedule.sort(key=lambda i: i['start'])
conference_schedules[conference][channel] = schedule
# Fill in day start / day end events for each conference day.
# (We need to work in the schedule's timezone for this to work properly.)
for conference in conference_schedules:
# First earliest and latest event in a conference.
all_events = []
for channel_schedule in conference_schedules[conference].values():
all_events.extend(channel_schedule)
all_events.sort(key=lambda i: i['start'])
if len(all_events) == 0:
# No events this day
sys.stderr.write("There are no events in %r\n" % (conference,))
continue
starting_event = all_events[0]
ending_event = all_events[-1]
for channel in conference_schedules[conference]:
oldevents = conference_schedules[conference][channel]
config = CONFIG.config(channel)
if not config['schedule-timezone']:
sys.stderr.write("%s has not timezone, can't add conference day events\n" % channel)
continue
tzinfo = pytz.timezone(config['schedule-timezone'])
# Group events onto days
perday_events = defaultdict(list)
for event in oldevents:
perday_events[event['end'].astimezone(tzinfo).date()].append(event)
# Remove any days which are 100% via another schedule.
for day in list(perday_events.keys()):
for event in perday_events[day]:
if not event.get('via', False):
break
else:
# All generated
del perday_events[day]
# Add in any missing days
startdate = datetime_tz.combine(
starting_event['start'].astimezone(tzinfo).date(),
datetime_tz.min.time(),
tzinfo)
enddate = datetime_tz.combine(
ending_event['start'].astimezone(tzinfo).date(),
datetime_tz.min.time(),
tzinfo)
for day in dt_iterate.days(startdate, enddate):
if day.date() not in perday_events:
day_skipped_event = {
'start': datetime_tz.combine(day, datetime_tz.min.time(), tzinfo).astimezone(pytz.utc),
'end': datetime_tz.combine(day, datetime_tz.max.time(), tzinfo).astimezone(pytz.utc),
'title': 'Nothing in %s today' % config['title'],
'abstract': '',
'generated': True,
}
perday_events[day.date()].append(day_skipped_event)
# Add start of day / end of day events
for day, events in perday_events.items():
if day > startdate.date() and events[0]['start'].astimezone(tzinfo).time() != datetime_tz.min.time():
events.insert(0, {
'start': datetime_tz.combine(day, datetime_tz.min.time(), tzinfo).astimezone(pytz.utc),
'end': events[0]['start'],
'title': 'Not yet started in %s' % config['title'],
'abstract': '',
'generated': True,
})
if day < enddate.date() and events[-1]['end'].astimezone(tzinfo).time() != datetime_tz.max.time():
events.append({
'start': events[-1]['end'],
'end': datetime_tz.combine(day, datetime_tz.max.time(), tzinfo).astimezone(pytz.utc),
'title': 'Finished for the day in %s' % config['title'],
'abstract': '',
'generated': True,
})
# Create a before conference start event.
before_event = {
'start': datetime_tz(datetime_tz.min.asdatetime(naive=True), tzinfo).astimezone(pytz.utc),
'end': starting_event['start'],
'title': '%s not yet started' % conference,
'abstract': '',
'generated': True,
}
# Create an after conference end event.
after_event = {
'start': ending_event['end'],
'end': datetime_tz(datetime_tz.max.asdatetime(naive=True), tzinfo).astimezone(pytz.utc),
'title': '%s finished :(' % conference,
'abstract': '',
'generated': True,
}
# Put everything back together
newevents = [before_event]
for day in sorted(perday_events.keys()):
newevents.extend(perday_events[day])
newevents.append(after_event)
conference_schedules[conference][channel] = newevents
# Fill in any gaps
for conference in conference_schedules:
for channel in conference_schedules[conference]:
oldevents = conference_schedules[conference][channel]
if len(oldevents) == 0:
# No events on day
continue
newevents = [oldevents.pop(0)]
conference_schedules[conference][channel] = newevents
while len(oldevents) > 0:
delta = oldevents[0]['start'] - newevents[-1]['end']
if delta.seconds > (5*60):
unknown_event = {
'start': newevents[-1]['end'],
'end': oldevents[0]['start'],
'abstract': '',
'generated': True,
}
unknown_event['title'] = '%i minute break' % ((unknown_event['end'] - unknown_event['start']).seconds/60)
newevents.append(unknown_event)
newevents.append(oldevents.pop(0))
# Add guid to each event
for conference in conference_schedules:
for channel in conference_schedules[conference]:
for item in conference_schedules[conference][channel]:
if 'guid' not in item:
item['guid'] = hashlib.md5(str(item['start'])+channel).hexdigest()
print_schedule(conference_schedules)
output_data = {}
for conference in conference_schedules:
for channel in conference_schedules[conference]:
output_data[channel] = conference_schedules[conference][channel]
out = StringIO.StringIO()
pprint.pprint(output_data, stream=out)
print """\
from datetime_tz import datetime_tz
import pytz
data = \\"""
print out.getvalue()
