def range_check_interval(cls, start=None, end=None, duration=None):
#Handles concise format, range checks any potential durations
if start is not None and end is not None:
#<start>/<end>
#Handle concise format
if cls._is_interval_end_concise(end) is True:
end = cls._combine_concise_interval_tuples(start, end)
return (start, end, duration)
durationobject = cls._build_object(duration)
if end is not None:
#<duration>/<end>
endobject = cls._build_object(end)
#Range check
if type(end) is DateTuple:
enddatetime = cls.build_datetime(end,
TupleBuilder.build_time())
if enddatetime - datetime.datetime.min < durationobject:
raise YearOutOfBoundsError(
'Interval end less than minimium date.')
else:
mindatetime = datetime.datetime.min
if end.time.tz is not None:
mindatetime = mindatetime.replace(tzinfo=endobject.tzinfo)
if endobject - mindatetime < durationobject:
raise YearOutOfBoundsError(
'Interval end less than minimium date.')
else:
#<start>/<duration>
startobject = cls._build_object(start)
#Range check
if type(start) is DateTuple:
startdatetime = cls.build_datetime(start,
TupleBuilder.build_time())
if datetime.datetime.max - startdatetime < durationobject:
raise YearOutOfBoundsError(
'Interval end greater than maximum date.')
else:
maxdatetime = datetime.datetime.max
if start.time.tz is not None:
maxdatetime = maxdatetime.replace(
tzinfo=startobject.tzinfo)
if maxdatetime - startobject < durationobject:
raise YearOutOfBoundsError(
'Interval end greater than maximum date.')
return (start, end, duration)
def test_build_date(self):
datetuple = TupleBuilder.build_date()
self.assertEqual(datetuple, (None, None, None,
None, None, None,
'date'))
datetuple = TupleBuilder.build_date(YYYY='1', MM='2', DD='3',
Www='4', D='5', DDD='6')
self.assertEqual(datetuple, ('1', '2', '3',
'4', '5', '6',
'date'))
def test_build_date(self):
datetuple = TupleBuilder.build_date()
self.assertEqual(datetuple,
(None, None, None, None, None, None, "date"))
datetuple = TupleBuilder.build_date(YYYY="1",
MM="2",
DD="3",
Www="4",
D="5",
DDD="6")
self.assertEqual(datetuple, ("1", "2", "3", "4", "5", "6", "date"))
def test_build_datetime(self):
testtuples = (
(
{
"date": DateTuple("1", "2", "3", "4", "5", "6"),
"time": TimeTuple("7", "8", "9", None),
},
DatetimeTuple(
DateTuple("1", "2", "3", "4", "5", "6"),
TimeTuple("7", "8", "9", None),
),
),
(
{
"date":
DateTuple("1", "2", "3", "4", "5", "6"),
"time":
TimeTuple(
"7", "8", "9",
TimezoneTuple(True, False, "10", "11", "tz name")),
},
DatetimeTuple(
DateTuple("1", "2", "3", "4", "5", "6"),
TimeTuple(
"7", "8", "9",
TimezoneTuple(True, False, "10", "11", "tz name")),
),
),
)
for testtuple in testtuples:
self.assertEqual(TupleBuilder.build_datetime(**testtuple[0]),
testtuple[1])
def test_build_time(self):
testtuples = (({}, TimeTuple(None, None, None, None)), ({
'hh': '1',
'mm': '2',
'ss': '3',
'tz': None
}, TimeTuple('1', '2', '3',
None)), ({
'hh':
'1',
'mm':
'2',
'ss':
'3',
'tz':
TimezoneTuple(False, False, '4', '5', 'tz name')
},
TimeTuple(
'1', '2', '3',
TimezoneTuple(False, False, '4', '5',
'tz name'))))
for testtuple in testtuples:
self.assertEqual(TupleBuilder.build_time(**testtuple[0]),
testtuple[1])
def test_build_time(self):
testtuples = (
({}, (None, None, None, None, "time")),
(
{
"hh": "1",
"mm": "2",
"ss": "3",
"tz": None
},
("1", "2", "3", None, "time"),
),
(
{
"hh": "1",
"mm": "2",
"ss": "3",
"tz": (False, False, "4", "5", "tz name", "timezone"),
},
(
"1",
"2",
"3",
(False, False, "4", "5", "tz name", "timezone"),
"time",
),
),
)
for testtuple in testtuples:
self.assertEqual(TupleBuilder.build_time(**testtuple[0]),
testtuple[1])
def test_build_timezone(self):
testtuples = (({}, (None, None, None, None, '', 'timezone')), ({
'negative':
False,
'Z':
True,
'name':
'UTC'
}, (False, True, None, None, 'UTC', 'timezone')), ({
'negative': False,
'Z': False,
'hh': '1',
'mm': '2',
'name': '+01:02'
}, (False, False, '1', '2', '+01:02', 'timezone')), ({
'negative': True,
'Z': False,
'hh': '1',
'mm': '2',
'name': '-01:02'
}, (True, False, '1', '2', '-01:02', 'timezone')))
for testtuple in testtuples:
result = TupleBuilder.build_timezone(**testtuple[0])
self.assertEqual(result, testtuple[1])
def test_build_datetime(self):
testtuples = (({
'date': DateTuple('1', '2', '3', '4', '5', '6'),
'time': TimeTuple('7', '8', '9', None)
},
DatetimeTuple(DateTuple('1', '2', '3', '4', '5', '6'),
TimeTuple('7', '8', '9', None))),
({
'date':
DateTuple('1', '2', '3', '4', '5', '6'),
'time':
TimeTuple(
'7', '8', '9',
TimezoneTuple(True, False, '10', '11',
'tz name'))
},
DatetimeTuple(
DateTuple('1', '2', '3', '4', '5', '6'),
TimeTuple(
'7', '8', '9',
TimezoneTuple(True, False, '10', '11',
'tz name')))))
for testtuple in testtuples:
self.assertEqual(TupleBuilder.build_datetime(**testtuple[0]),
testtuple[1])
def test_build_repeating_interval(self):
testtuples = (({}, (None, None, None, 'repeatinginterval')),
({'R': True,
'interval': (('1', '2', '3', '4', '5', '6', 'date'),
('7', '8', '9', '10', '11', '12', 'date'),
None, 'interval')},
(True, None, (('1', '2', '3', '4', '5', '6', 'date'),
('7', '8', '9', '10', '11', '12', 'date'),
None, 'interval'),
'repeatinginterval')),
({'R': False, 'Rnn': '1',
'interval': ((('2', '3', '4', '5', '6', '7',
'date'),
('8', '9', '10', None, 'time'),
'datetime'),
(('11', '12', '13', '14', '15', '16',
'date'),
('17', '18', '19', None, 'time'),
'datetime'),
None, 'interval')},
(False, '1',
((('2', '3', '4', '5', '6', '7',
'date'),
('8', '9', '10', None, 'time'),
'datetime'),
(('11', '12', '13', '14', '15', '16',
'date'),
('17', '18', '19', None, 'time'),
'datetime'),
None, 'interval'),
'repeatinginterval')))
for testtuple in testtuples:
result = TupleBuilder.build_repeating_interval(**testtuple[0])
self.assertEqual(result, testtuple[1])
def build_interval(cls, start=None, end=None, duration=None):
start, end, duration = cls.range_check_interval(start, end, duration)
if start is not None and end is not None:
# <start>/<end>
startobject = cls._build_object(start)
endobject = cls._build_object(end)
return (startobject, endobject)
durationobject = cls._build_object(duration)
# Determine if datetime promotion is required
datetimerequired = (duration.TnH is not None
or duration.TnM is not None
or duration.TnS is not None
or durationobject.seconds != 0
or durationobject.microseconds != 0)
if end is not None:
# <duration>/<end>
endobject = cls._build_object(end)
# Range check
if type(end) is DateTuple and datetimerequired is True:
# <end> is a date, and <duration> requires datetime resolution
return (
endobject,
cls.build_datetime(end, TupleBuilder.build_time()) -
durationobject,
)
return (endobject, endobject - durationobject)
# <start>/<duration>
startobject = cls._build_object(start)
# Range check
if type(start) is DateTuple and datetimerequired is True:
# <start> is a date, and <duration> requires datetime resolution
return (
startobject,
cls.build_datetime(start, TupleBuilder.build_time()) +
durationobject,
)
return (startobject, startobject + durationobject)
def build_interval(cls, start=None, end=None, duration=None):
if start is not None and end is not None:
# <start>/<end>
startobject = cls._build_object(start)
endobject = cls._build_object(end)
return (startobject, endobject)
durationobject = cls._build_object(duration)
# Determine if datetime promotion is required
datetimerequired = (
duration[4] is not None
or duration[5] is not None
or duration[6] is not None
or durationobject.seconds != 0
or durationobject.microseconds != 0
)
if end is not None:
# <duration>/<end>
endobject = cls._build_object(end)
if end[-1] == "date" and datetimerequired is True:
# <end> is a date, and <duration> requires datetime resolution
return (
endobject,
cls.build_datetime(end, TupleBuilder.build_time()) - durationobject,
)
return (endobject, endobject - durationobject)
# <start>/<duration>
startobject = cls._build_object(start)
if start[-1] == "date" and datetimerequired is True:
# <start> is a date, and <duration> requires datetime resolution
return (
startobject,
cls.build_datetime(start, TupleBuilder.build_time()) + durationobject,
)
return (startobject, startobject + durationobject)
def test_build_duration(self):
testtuples = (({}, (None, None, None, None, None, None, None,
'duration')),
({'PnY': '1', 'PnM': '2', 'PnW': '3', 'PnD': '4',
'TnH': '5', 'TnM': '6', 'TnS': '7'},
('1', '2', '3', '4',
'5', '6', '7',
'duration')))
for testtuple in testtuples:
self.assertEqual(TupleBuilder.build_duration(**testtuple[0]),
testtuple[1])
def test_build_interval(self):
testtuples = (({}, (None, None, None, 'interval')), ({
'start': ('1', '2', '3', '4', '5', '6', 'date'),
'end': ('7', '8', '9', '10', '11', '12', 'date')
}, (('1', '2', '3', '4', '5', '6', 'date'),
('7', '8', '9', '10', '11', '12', 'date'), None, 'interval')), ({
'start': ('1', '2', '3', (True, False, '7', '8', 'tz name',
'timezone'), 'time'),
'end': ('4', '5', '6', (False, False, '9', '10', 'tz name',
'timezone'), 'time')
}, (('1', '2', '3', (True, False, '7', '8', 'tz name', 'timezone'),
'time'), ('4', '5', '6', (False, False, '9', '10', 'tz name',
'timezone'), 'time'), None,
'interval')), ({
'start':
(('1', '2', '3', '4', '5', '6', 'date'),
('7', '8', '9', (True, False, '10', '11', 'tz name',
'timezone'), 'time'), 'datetime'),
'end':
(('12', '13', '14', '15', '16', '17', 'date'),
('18', '19', '20', (False, False, '21', '22', 'tz name',
'timezone'), 'time'), 'datetime')
}, ((('1', '2', '3', '4', '5', '6', 'date'),
('7', '8', '9', (True, False, '10', '11', 'tz name',
'timezone'), 'time'), 'datetime'),
(('12', '13', '14', '15', '16', '17', 'date'),
('18', '19', '20', (False, False, '21', '22', 'tz name',
'timezone'), 'time'), 'datetime'),
None, 'interval')), ({
'start': ('1', '2', '3', '4', '5', '6', 'date'),
'end':
None,
'duration':
('7', '8', '9', '10', '11', '12', '13', 'duration')
}, (('1', '2', '3', '4', '5', '6', 'date'), None,
('7', '8', '9', '10', '11', '12', '13',
'duration'), 'interval')), ({
'start':
None,
'end':
('1', '2', '3', (True, False, '4', '5', 'tz name',
'timezone'), 'time'),
'duration':
('6', '7', '8', '9', '10', '11', '12', 'duration')
}, (None, ('1', '2', '3', (True, False, '4', '5',
'tz name', 'timezone'),
'time'), ('6', '7', '8', '9', '10', '11',
'12', 'duration'), 'interval')))
for testtuple in testtuples:
self.assertEqual(TupleBuilder.build_interval(**testtuple[0]),
testtuple[1])
def test_build_repeating_interval(self):
testtuples = (({}, RepeatingIntervalTuple(
None, None, None)), ({
'R':
True,
'interval':
IntervalTuple(DateTuple('1', '2', '3', '4', '5', '6'),
DateTuple('7', '8', '9', '10', '11', '12'), None)
},
RepeatingIntervalTuple(
True, None,
IntervalTuple(
DateTuple('1', '2', '3', '4', '5',
'6'),
DateTuple('7', '8', '9', '10', '11',
'12'), None))),
({
'R':
False,
'Rnn':
'1',
'interval':
IntervalTuple(
DatetimeTuple(
DateTuple('2', '3', '4', '5', '6', '7'),
TimeTuple('8', '9', '10', None)),
DatetimeTuple(
DateTuple('11', '12', '13', '14', '15',
'16'),
TimeTuple('17', '18', '19', None)), None)
},
RepeatingIntervalTuple(
False, '1',
IntervalTuple(
DatetimeTuple(
DateTuple('2', '3', '4', '5', '6', '7'),
TimeTuple('8', '9', '10', None)),
DatetimeTuple(
DateTuple('11', '12', '13', '14', '15',
'16'),
TimeTuple('17', '18', '19', None)), None))))
for testtuple in testtuples:
result = TupleBuilder.build_repeating_interval(**testtuple[0])
self.assertEqual(result, testtuple[1])
def test_build_duration(self):
testtuples = (
({}, (None, None, None, None, None, None, None, "duration")),
(
{
"PnY": "1",
"PnM": "2",
"PnW": "3",
"PnD": "4",
"TnH": "5",
"TnM": "6",
"TnS": "7",
},
("1", "2", "3", "4", "5", "6", "7", "duration"),
),
)
for testtuple in testtuples:
self.assertEqual(TupleBuilder.build_duration(**testtuple[0]),
testtuple[1])
def test_build_timezone(self):
testtuples = (
({}, (None, None, None, None, "", "timezone")),
(
{
"negative": False,
"Z": True,
"name": "UTC"
},
(False, True, None, None, "UTC", "timezone"),
),
(
{
"negative": False,
"Z": False,
"hh": "1",
"mm": "2",
"name": "+01:02"
},
(False, False, "1", "2", "+01:02", "timezone"),
),
(
{
"negative": True,
"Z": False,
"hh": "1",
"mm": "2",
"name": "-01:02"
},
(True, False, "1", "2", "-01:02", "timezone"),
),
)
for testtuple in testtuples:
result = TupleBuilder.build_timezone(**testtuple[0])
self.assertEqual(result, testtuple[1])
def test_build_interval(self):
testtuples = (
({}, IntervalTuple(None, None, None)),
(
{
"start": DateTuple("1", "2", "3", "4", "5", "6"),
"end": DateTuple("7", "8", "9", "10", "11", "12"),
},
IntervalTuple(
DateTuple("1", "2", "3", "4", "5", "6"),
DateTuple("7", "8", "9", "10", "11", "12"),
None,
),
),
(
{
"start":
TimeTuple("1", "2", "3",
TimezoneTuple(True, False, "7", "8", "tz name")),
"end":
TimeTuple(
"4", "5", "6",
TimezoneTuple(False, False, "9", "10", "tz name")),
},
IntervalTuple(
TimeTuple("1", "2", "3",
TimezoneTuple(True, False, "7", "8", "tz name")),
TimeTuple(
"4", "5", "6",
TimezoneTuple(False, False, "9", "10", "tz name")),
None,
),
),
(
{
"start":
DatetimeTuple(
DateTuple("1", "2", "3", "4", "5", "6"),
TimeTuple(
"7",
"8",
"9",
TimezoneTuple(True, False, "10", "11", "tz name"),
),
),
"end":
DatetimeTuple(
DateTuple("12", "13", "14", "15", "16", "17"),
TimeTuple(
"18",
"19",
"20",
TimezoneTuple(False, False, "21", "22", "tz name"),
),
),
},
IntervalTuple(
DatetimeTuple(
DateTuple("1", "2", "3", "4", "5", "6"),
TimeTuple(
"7",
"8",
"9",
TimezoneTuple(True, False, "10", "11", "tz name"),
),
),
DatetimeTuple(
DateTuple("12", "13", "14", "15", "16", "17"),
TimeTuple(
"18",
"19",
"20",
TimezoneTuple(False, False, "21", "22", "tz name"),
),
),
None,
),
),
(
{
"start":
DateTuple("1", "2", "3", "4", "5", "6"),
"end":
None,
"duration":
DurationTuple("7", "8", "9", "10", "11", "12", "13"),
},
IntervalTuple(
DateTuple("1", "2", "3", "4", "5", "6"),
None,
DurationTuple("7", "8", "9", "10", "11", "12", "13"),
),
),
(
{
"start":
None,
"end":
TimeTuple("1", "2", "3",
TimezoneTuple(True, False, "4", "5", "tz name")),
"duration":
DurationTuple("6", "7", "8", "9", "10", "11", "12"),
},
IntervalTuple(
None,
TimeTuple("1", "2", "3",
TimezoneTuple(True, False, "4", "5", "tz name")),
DurationTuple("6", "7", "8", "9", "10", "11", "12"),
),
),
)
for testtuple in testtuples:
self.assertEqual(TupleBuilder.build_interval(**testtuple[0]),
testtuple[1])
def test_build_repeating_interval(self):
testtuples = (
({}, (None, None, None, "repeatinginterval")),
(
{
"R":
True,
"interval": (
("1", "2", "3", "4", "5", "6", "date"),
("7", "8", "9", "10", "11", "12", "date"),
None,
"interval",
),
},
(
True,
None,
(
("1", "2", "3", "4", "5", "6", "date"),
("7", "8", "9", "10", "11", "12", "date"),
None,
"interval",
),
"repeatinginterval",
),
),
(
{
"R":
False,
"Rnn":
"1",
"interval": (
(
("2", "3", "4", "5", "6", "7", "date"),
("8", "9", "10", None, "time"),
"datetime",
),
(
("11", "12", "13", "14", "15", "16", "date"),
("17", "18", "19", None, "time"),
"datetime",
),
None,
"interval",
),
},
(
False,
"1",
(
(
("2", "3", "4", "5", "6", "7", "date"),
("8", "9", "10", None, "time"),
"datetime",
),
(
("11", "12", "13", "14", "15", "16", "date"),
("17", "18", "19", None, "time"),
"datetime",
),
None,
"interval",
),
"repeatinginterval",
),
),
)
for testtuple in testtuples:
result = TupleBuilder.build_repeating_interval(**testtuple[0])
self.assertEqual(result, testtuple[1])
def test_build_interval(self):
testtuples = (
({}, (None, None, None, "interval")),
(
{
"start": ("1", "2", "3", "4", "5", "6", "date"),
"end": ("7", "8", "9", "10", "11", "12", "date"),
},
(
("1", "2", "3", "4", "5", "6", "date"),
("7", "8", "9", "10", "11", "12", "date"),
None,
"interval",
),
),
(
{
"start": (
"1",
"2",
"3",
(True, False, "7", "8", "tz name", "timezone"),
"time",
),
"end": (
"4",
"5",
"6",
(False, False, "9", "10", "tz name", "timezone"),
"time",
),
},
(
(
"1",
"2",
"3",
(True, False, "7", "8", "tz name", "timezone"),
"time",
),
(
"4",
"5",
"6",
(False, False, "9", "10", "tz name", "timezone"),
"time",
),
None,
"interval",
),
),
(
{
"start": (
("1", "2", "3", "4", "5", "6", "date"),
(
"7",
"8",
"9",
(True, False, "10", "11", "tz name", "timezone"),
"time",
),
"datetime",
),
"end": (
("12", "13", "14", "15", "16", "17", "date"),
(
"18",
"19",
"20",
(False, False, "21", "22", "tz name", "timezone"),
"time",
),
"datetime",
),
},
(
(
("1", "2", "3", "4", "5", "6", "date"),
(
"7",
"8",
"9",
(True, False, "10", "11", "tz name", "timezone"),
"time",
),
"datetime",
),
(
("12", "13", "14", "15", "16", "17", "date"),
(
"18",
"19",
"20",
(False, False, "21", "22", "tz name", "timezone"),
"time",
),
"datetime",
),
None,
"interval",
),
),
(
{
"start": ("1", "2", "3", "4", "5", "6", "date"),
"end":
None,
"duration":
("7", "8", "9", "10", "11", "12", "13", "duration"),
},
(
("1", "2", "3", "4", "5", "6", "date"),
None,
("7", "8", "9", "10", "11", "12", "13", "duration"),
"interval",
),
),
(
{
"start":
None,
"end": (
"1",
"2",
"3",
(True, False, "4", "5", "tz name", "timezone"),
"time",
),
"duration":
("6", "7", "8", "9", "10", "11", "12", "duration"),
},
(
None,
(
"1",
"2",
"3",
(True, False, "4", "5", "tz name", "timezone"),
"time",
),
("6", "7", "8", "9", "10", "11", "12", "duration"),
"interval",
),
),
)
for testtuple in testtuples:
self.assertEqual(TupleBuilder.build_interval(**testtuple[0]),
testtuple[1])
def test_build_repeating_interval(self):
testtuples = (
({}, RepeatingIntervalTuple(None, None, None)),
(
{
"R":
True,
"interval":
IntervalTuple(
DateTuple("1", "2", "3", "4", "5", "6"),
DateTuple("7", "8", "9", "10", "11", "12"),
None,
),
},
RepeatingIntervalTuple(
True,
None,
IntervalTuple(
DateTuple("1", "2", "3", "4", "5", "6"),
DateTuple("7", "8", "9", "10", "11", "12"),
None,
),
),
),
(
{
"R":
False,
"Rnn":
"1",
"interval":
IntervalTuple(
DatetimeTuple(
DateTuple("2", "3", "4", "5", "6", "7"),
TimeTuple("8", "9", "10", None),
),
DatetimeTuple(
DateTuple("11", "12", "13", "14", "15", "16"),
TimeTuple("17", "18", "19", None),
),
None,
),
},
RepeatingIntervalTuple(
False,
"1",
IntervalTuple(
DatetimeTuple(
DateTuple("2", "3", "4", "5", "6", "7"),
TimeTuple("8", "9", "10", None),
),
DatetimeTuple(
DateTuple("11", "12", "13", "14", "15", "16"),
TimeTuple("17", "18", "19", None),
),
None,
),
),
),
)
for testtuple in testtuples:
result = TupleBuilder.build_repeating_interval(**testtuple[0])
self.assertEqual(result, testtuple[1])
def _parse_interval_end(endstr, starttuple, datetimedelimiter):
datestr = None
timestr = None
monthstr = None
daystr = None
concise = False
if type(starttuple) is DateTuple:
startdatetuple = starttuple
else:
#Start is a datetime
startdatetuple = starttuple.date
if datetimedelimiter in endstr:
datestr, timestr = endstr.split(datetimedelimiter, 1)
elif ':' in endstr:
timestr = endstr
else:
datestr = endstr
if timestr is not None:
endtimetuple = parse_time(timestr, builder=TupleBuilder)
#End is just a time
if datestr is None:
return endtimetuple
#Handle backwards concise representation
if datestr.count('-') == 1:
monthstr, daystr = datestr.split('-')
concise = True
elif len(datestr) <= 2:
daystr = datestr
concise = True
elif len(datestr) <= 4:
monthstr = datestr[0:2]
daystr = datestr[2:]
concise = True
if concise is True:
concisedatestr = startdatetuple.YYYY
#Separators required because concise elements may be missing digits
if monthstr is not None:
concisedatestr += '-' + monthstr
elif startdatetuple.MM is not None:
concisedatestr += '-' + startdatetuple.MM
concisedatestr += '-' + daystr
enddatetuple = parse_date(concisedatestr, builder=TupleBuilder)
#Clear unsupplied components
if monthstr is None:
enddatetuple = TupleBuilder.build_date(DD=enddatetuple.DD)
else:
#Year not provided
enddatetuple = TupleBuilder.build_date(MM=enddatetuple.MM,
DD=enddatetuple.DD)
else:
enddatetuple = parse_date(datestr, builder=TupleBuilder)
if timestr is None:
return enddatetuple
return TupleBuilder.build_datetime(enddatetuple, endtimetuple)
def test_build_interval(self):
testtuples = (({}, IntervalTuple(
None, None,
None)), ({
'start': DateTuple('1', '2', '3', '4', '5', '6'),
'end': DateTuple('7', '8', '9', '10', '11', '12')
},
IntervalTuple(DateTuple('1', '2', '3', '4', '5', '6'),
DateTuple('7', '8', '9', '10', '11', '12'),
None)),
({
'start':
TimeTuple(
'1',
'2',
'3',
TimezoneTuple(True, False, '7', '8', 'tz name')),
'end':
TimeTuple(
'4',
'5',
'6',
TimezoneTuple(False, False, '9', '10',
'tz name'))
},
IntervalTuple(
TimeTuple(
'1', '2', '3',
TimezoneTuple(True, False, '7', '8',
'tz name')),
TimeTuple(
'4', '5', '6',
TimezoneTuple(False, False, '9', '10',
'tz name')), None)),
({
'start':
DatetimeTuple(
DateTuple('1', '2', '3', '4', '5',
'6'),
TimeTuple(
'7',
'8',
'9',
TimezoneTuple(True, False, '10', '11',
'tz name'))),
'end':
DatetimeTuple(
DateTuple('12', '13', '14', '15', '16', '17'),
TimeTuple(
'18', '19', '20',
TimezoneTuple(False, False, '21', '22',
'tz name')))
},
IntervalTuple(
DatetimeTuple(
DateTuple('1', '2', '3', '4', '5', '6'),
TimeTuple(
'7', '8', '9',
TimezoneTuple(True, False, '10', '11',
'tz name'))),
DatetimeTuple(
DateTuple('12', '13', '14', '15', '16', '17'),
TimeTuple(
'18', '19', '20',
TimezoneTuple(False, False, '21', '22',
'tz name'))),
None)), ({
'start':
DateTuple('1', '2', '3', '4', '5', '6'),
'end':
None,
'duration':
DurationTuple('7', '8', '9', '10', '11', '12',
'13')
},
IntervalTuple(
DateTuple('1', '2', '3', '4', '5',
'6'), None,
DurationTuple('7', '8', '9', '10',
'11', '12', '13'))),
({
'start':
None,
'end':
TimeTuple(
'1', '2', '3',
TimezoneTuple(True, False, '4', '5', 'tz name')),
'duration':
DurationTuple('6', '7', '8', '9', '10', '11', '12')
},
IntervalTuple(
None,
TimeTuple(
'1', '2', '3',
TimezoneTuple(True, False, '4', '5',
'tz name')),
DurationTuple('6', '7', '8', '9', '10', '11',
'12'))))
for testtuple in testtuples:
self.assertEqual(TupleBuilder.build_interval(**testtuple[0]),
testtuple[1])
