def test_cast_caughtexception(self):
def tester(value):
raise RuntimeError
with self.assertRaises(ISOFormatError):
BaseTimeBuilder.cast('asdf', tester,
caughtexceptions=(RuntimeError,))
def test_range_check_repeating_interval(self):
self.assertEqual(BaseTimeBuilder.range_check_repeating_interval(),
(None, None, None))
self.assertEqual(
BaseTimeBuilder.range_check_repeating_interval(rangedict={}),
(None, None, None))
def test_range_check_timezone(self):
self.assertEqual(BaseTimeBuilder.range_check_timezone(),
(None, None, None, None, ""))
self.assertEqual(
BaseTimeBuilder.range_check_timezone(rangedict={}),
(None, None, None, None, ""),
)
def test_range_check_duration(self):
self.assertEqual(
BaseTimeBuilder.range_check_duration(),
(None, None, None, None, None, None, None),
)
self.assertEqual(
BaseTimeBuilder.range_check_duration(rangedict={}),
(None, None, None, None, None, None, None),
)
def test_is_interval_end_concise(self):
self.assertTrue(
BaseTimeBuilder._is_interval_end_concise(
TimeTuple('1', '2', '3', None)))
self.assertTrue(
BaseTimeBuilder._is_interval_end_concise(
DateTuple(None, '2', '3', '4', '5', '6')))
self.assertTrue(
BaseTimeBuilder._is_interval_end_concise(
DatetimeTuple(DateTuple(None, '2', '3', '4', '5', '6'),
TimeTuple('7', '8', '9', None))))
self.assertFalse(
BaseTimeBuilder._is_interval_end_concise(
DateTuple('1', '2', '3', '4', '5', '6')))
self.assertFalse(
BaseTimeBuilder._is_interval_end_concise(
DatetimeTuple(DateTuple('1', '2', '3', '4', '5', '6'),
TimeTuple('7', '8', '9', None))))
def test_combine_concise_interval_tuples(self):
testtuples = ((DateTuple('2020', '01', '01', None, None, None),
DateTuple(None, None, '02', None, None, None),
DateTuple('2020', '01', '02', None, None,
None)), (DateTuple('2008', '02', '15', None,
None, None),
DateTuple(None, '03', '14', None,
None, None),
DateTuple('2008', '03', '14', None,
None, None)),
(DatetimeTuple(
DateTuple('2007', '12', '14', None, None, None),
TimeTuple('13', '30', None,
None)), TimeTuple('15', '30', None, None),
DatetimeTuple(
DateTuple('2007', '12', '14', None, None, None),
TimeTuple('15', '30', None, None))),
(DatetimeTuple(
DateTuple('2007', '11', '13', None, None, None),
TimeTuple('09', '00', None, None)),
DatetimeTuple(
DateTuple(None, None, '15', None, None, None),
TimeTuple('17', '00', None, None)),
DatetimeTuple(
DateTuple('2007', '11', '15', None, None, None),
TimeTuple('17', '00', None, None))),
(DatetimeTuple(
DateTuple('2007', '11', '13', None, None, None),
TimeTuple('00', '00', None, None)),
DatetimeTuple(
DateTuple(None, None, '16', None, None, None),
TimeTuple('00', '00', None, None)),
DatetimeTuple(
DateTuple('2007', '11', '16', None, None, None),
TimeTuple('00', '00', None, None))),
(DatetimeTuple(
DateTuple('2007', '11', '13', None, None, None),
TimeTuple(
'09', '00', None,
TimezoneTuple(False, True, None, None, 'Z'))),
DatetimeTuple(
DateTuple(None, None, '15', None, None, None),
TimeTuple('17', '00', None, None)),
DatetimeTuple(
DateTuple('2007', '11', '15', None, None, None),
TimeTuple(
'17', '00', None,
TimezoneTuple(False, True, None, None, 'Z')))))
for testtuple in testtuples:
result = BaseTimeBuilder._combine_concise_interval_tuples(
testtuple[0], testtuple[1])
self.assertEqual(result, testtuple[2])
def test_cast(self):
self.assertEqual(BaseTimeBuilder.cast('1', int), 1)
self.assertEqual(BaseTimeBuilder.cast('-2', int), -2)
self.assertEqual(BaseTimeBuilder.cast('3', float), float(3))
self.assertEqual(BaseTimeBuilder.cast('-4', float), float(-4))
self.assertEqual(BaseTimeBuilder.cast('5.6', float), 5.6)
self.assertEqual(BaseTimeBuilder.cast('-7.8', float), -7.8)
def test_cast(self):
self.assertEqual(BaseTimeBuilder.cast("1", int), 1)
self.assertEqual(BaseTimeBuilder.cast("-2", int), -2)
self.assertEqual(BaseTimeBuilder.cast("3", float), float(3))
self.assertEqual(BaseTimeBuilder.cast("-4", float), float(-4))
self.assertEqual(BaseTimeBuilder.cast("5.6", float), 5.6)
self.assertEqual(BaseTimeBuilder.cast("-7.8", float), -7.8)
def test_is_interval_end_concise(self):
self.assertTrue(
BaseTimeBuilder._is_interval_end_concise(
TimeTuple("1", "2", "3", None)))
self.assertTrue(
BaseTimeBuilder._is_interval_end_concise(
DateTuple(None, "2", "3", "4", "5", "6")))
self.assertTrue(
BaseTimeBuilder._is_interval_end_concise(
DatetimeTuple(
DateTuple(None, "2", "3", "4", "5", "6"),
TimeTuple("7", "8", "9", None),
)))
self.assertFalse(
BaseTimeBuilder._is_interval_end_concise(
DateTuple("1", "2", "3", "4", "5", "6")))
self.assertFalse(
BaseTimeBuilder._is_interval_end_concise(
DatetimeTuple(
DateTuple("1", "2", "3", "4", "5", "6"),
TimeTuple("7", "8", "9", None),
)))
def test_build_object(self):
datetest = (
("1", "2", "3", "4", "5", "6", "date"),
{
"YYYY": "1",
"MM": "2",
"DD": "3",
"Www": "4",
"D": "5",
"DDD": "6"
},
)
timetest = (
("1", "2", "3", (False, False, "4", "5", "tz name", "timezone"),
"time"),
{
"hh": "1",
"mm": "2",
"ss": "3",
"tz": (False, False, "4", "5", "tz name", "timezone"),
},
)
datetimetest = (
(
("1", "2", "3", "4", "5", "6", "date"),
(
"7",
"8",
"9",
(True, False, "10", "11", "tz name", "timezone"),
"time",
),
"datetime",
),
(
("1", "2", "3", "4", "5", "6", "date"),
(
"7",
"8",
"9",
(True, False, "10", "11", "tz name", "timezone"),
"time",
),
),
)
durationtest = (
("1", "2", "3", "4", "5", "6", "7", "duration"),
{
"PnY": "1",
"PnM": "2",
"PnW": "3",
"PnD": "4",
"TnH": "5",
"TnM": "6",
"TnS": "7",
},
)
intervaltests = (
(
(
("1", "2", "3", "4", "5", "6", "date"),
("7", "8", "9", "10", "11", "12", "date"),
None,
"interval",
),
{
"start": ("1", "2", "3", "4", "5", "6", "date"),
"end": ("7", "8", "9", "10", "11", "12", "date"),
"duration": None,
},
),
(
(
("1", "2", "3", "4", "5", "6", "date"),
None,
("7", "8", "9", "10", "11", "12", "13", "duration"),
"interval",
),
{
"start": ("1", "2", "3", "4", "5", "6", "date"),
"end":
None,
"duration":
("7", "8", "9", "10", "11", "12", "13", "duration"),
},
),
(
(
None,
(
"1",
"2",
"3",
(True, False, "4", "5", "tz name", "timezone"),
"time",
),
("6", "7", "8", "9", "10", "11", "12", "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"),
},
),
)
repeatingintervaltests = (
(
(
True,
None,
(
("1", "2", "3", "4", "5", "6", "date"),
("7", "8", "9", "10", "11", "12", "date"),
None,
"interval",
),
"repeatinginterval",
),
{
"R":
True,
"Rnn":
None,
"interval": (
("1", "2", "3", "4", "5", "6", "date"),
("7", "8", "9", "10", "11", "12", "date"),
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",
),
{
"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",
),
},
),
)
timezonetest = (
(False, False, "1", "2", "+01:02", "timezone"),
{
"negative": False,
"Z": False,
"hh": "1",
"mm": "2",
"name": "+01:02"
},
)
with mock.patch.object(aniso8601.builders.BaseTimeBuilder,
"build_date") as mock_build:
mock_build.return_value = datetest[0]
result = BaseTimeBuilder._build_object(datetest[0])
self.assertEqual(result, datetest[0])
mock_build.assert_called_once_with(**datetest[1])
with mock.patch.object(aniso8601.builders.BaseTimeBuilder,
"build_time") as mock_build:
mock_build.return_value = timetest[0]
result = BaseTimeBuilder._build_object(timetest[0])
self.assertEqual(result, timetest[0])
mock_build.assert_called_once_with(**timetest[1])
with mock.patch.object(aniso8601.builders.BaseTimeBuilder,
"build_datetime") as mock_build:
mock_build.return_value = datetimetest[0]
result = BaseTimeBuilder._build_object(datetimetest[0])
self.assertEqual(result, datetimetest[0])
mock_build.assert_called_once_with(*datetimetest[1])
with mock.patch.object(aniso8601.builders.BaseTimeBuilder,
"build_duration") as mock_build:
mock_build.return_value = durationtest[0]
result = BaseTimeBuilder._build_object(durationtest[0])
self.assertEqual(result, durationtest[0])
mock_build.assert_called_once_with(**durationtest[1])
for intervaltest in intervaltests:
with mock.patch.object(aniso8601.builders.BaseTimeBuilder,
"build_interval") as mock_build:
mock_build.return_value = intervaltest[0]
result = BaseTimeBuilder._build_object(intervaltest[0])
self.assertEqual(result, intervaltest[0])
mock_build.assert_called_once_with(**intervaltest[1])
for repeatingintervaltest in repeatingintervaltests:
with mock.patch.object(aniso8601.builders.BaseTimeBuilder,
"build_repeating_interval") as mock_build:
mock_build.return_value = repeatingintervaltest[0]
result = BaseTimeBuilder._build_object(
repeatingintervaltest[0])
self.assertEqual(result, repeatingintervaltest[0])
mock_build.assert_called_once_with(**repeatingintervaltest[1])
with mock.patch.object(aniso8601.builders.BaseTimeBuilder,
"build_timezone") as mock_build:
mock_build.return_value = timezonetest[0]
result = BaseTimeBuilder._build_object(timezonetest[0])
self.assertEqual(result, timezonetest[0])
mock_build.assert_called_once_with(**timezonetest[1])
def test_cast_thrownexception(self):
with self.assertRaises(RuntimeError):
BaseTimeBuilder.cast("asdf", int, thrownexception=RuntimeError)
def test_cast_exception(self):
with self.assertRaises(ISOFormatError):
BaseTimeBuilder.cast("asdf", int)
with self.assertRaises(ISOFormatError):
BaseTimeBuilder.cast("asdf", float)
def test_build_timezone(self):
with self.assertRaises(NotImplementedError):
BaseTimeBuilder.build_timezone()
def test_build_repeating_interval(self):
with self.assertRaises(NotImplementedError):
BaseTimeBuilder.build_repeating_interval()
def test_build_duration(self):
with self.assertRaises(NotImplementedError):
BaseTimeBuilder.build_duration()
def test_build_datetime(self):
with self.assertRaises(NotImplementedError):
BaseTimeBuilder.build_datetime(None, None)
def test_build_object(self):
datetest = (('1', '2', '3', '4', '5', '6', 'date'),
{'YYYY': '1', 'MM': '2', 'DD': '3',
'Www': '4', 'D': '5', 'DDD': '6'})
timetest = (('1', '2', '3',
(False, False, '4', '5', 'tz name', 'timezone'),
'time'),
{'hh': '1', 'mm': '2', 'ss': '3',
'tz': (False, False, '4', '5', 'tz name', 'timezone')})
datetimetest = ((('1', '2', '3', '4', '5', '6', 'date'),
('7', '8', '9',
(True, False, '10', '11', 'tz name', 'timezone'),
'time'),
'datetime'),
(('1', '2', '3', '4', '5', '6', 'date'),
('7', '8', '9',
(True, False, '10', '11', 'tz name', 'timezone'),
'time')))
durationtest = (('1', '2', '3', '4', '5', '6', '7', 'duration'),
{'PnY': '1', 'PnM': '2', 'PnW': '3', 'PnD': '4',
'TnH': '5', 'TnM': '6', 'TnS': '7'})
intervaltests = (((('1', '2', '3', '4', '5', '6', 'date'),
('7', '8', '9', '10', '11', '12', 'date'),
None, 'interval'),
{'start': ('1', '2', '3', '4', '5', '6', 'date'),
'end': ('7', '8', '9', '10', '11', '12', 'date'),
'duration': None}),
((('1', '2', '3', '4', '5', '6', 'date'),
None,
('7', '8', '9', '10', '11', '12', '13', 'duration'),
'interval'),
{'start': ('1', '2', '3', '4', '5', '6', 'date'),
'end': None,
'duration': ('7', '8', '9', '10', '11', '12', '13',
'duration')}),
((None,
('1', '2', '3',
(True, False, '4', '5', 'tz name', 'timezone'),
'time'),
('6', '7', '8', '9', '10', '11', '12', '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')}))
repeatingintervaltests = (((True,
None,
(('1', '2', '3', '4', '5', '6', 'date'),
('7', '8', '9', '10', '11', '12', 'date'),
None, 'interval'), 'repeatinginterval'),
{'R': True,
'Rnn': None,
'interval': (('1', '2', '3',
'4', '5', '6', 'date'),
('7', '8', '9',
'10', '11', '12', 'date'),
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'),
{'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')}))
timezonetest = ((False, False, '1', '2', '+01:02', 'timezone'),
{'negative': False, 'Z': False,
'hh': '1', 'mm': '2', 'name': '+01:02'})
with mock.patch.object(aniso8601.builders.BaseTimeBuilder,
'build_date') as mock_build:
mock_build.return_value = datetest[0]
result = BaseTimeBuilder._build_object(datetest[0])
self.assertEqual(result, datetest[0])
mock_build.assert_called_once_with(**datetest[1])
with mock.patch.object(aniso8601.builders.BaseTimeBuilder,
'build_time') as mock_build:
mock_build.return_value = timetest[0]
result = BaseTimeBuilder._build_object(timetest[0])
self.assertEqual(result, timetest[0])
mock_build.assert_called_once_with(**timetest[1])
with mock.patch.object(aniso8601.builders.BaseTimeBuilder,
'build_datetime') as mock_build:
mock_build.return_value = datetimetest[0]
result = BaseTimeBuilder._build_object(datetimetest[0])
self.assertEqual(result, datetimetest[0])
mock_build.assert_called_once_with(*datetimetest[1])
with mock.patch.object(aniso8601.builders.BaseTimeBuilder,
'build_duration') as mock_build:
mock_build.return_value = durationtest[0]
result = BaseTimeBuilder._build_object(durationtest[0])
self.assertEqual(result, durationtest[0])
mock_build.assert_called_once_with(**durationtest[1])
for intervaltest in intervaltests:
with mock.patch.object(aniso8601.builders.BaseTimeBuilder,
'build_interval') as mock_build:
mock_build.return_value = intervaltest[0]
result = BaseTimeBuilder._build_object(intervaltest[0])
self.assertEqual(result, intervaltest[0])
mock_build.assert_called_once_with(**intervaltest[1])
for repeatingintervaltest in repeatingintervaltests:
with mock.patch.object(aniso8601.builders.BaseTimeBuilder,
'build_repeating_interval') as mock_build:
mock_build.return_value = repeatingintervaltest[0]
result = BaseTimeBuilder._build_object(repeatingintervaltest[0])
self.assertEqual(result, repeatingintervaltest[0])
mock_build.assert_called_once_with(**repeatingintervaltest[1])
with mock.patch.object(aniso8601.builders.BaseTimeBuilder,
'build_timezone') as mock_build:
mock_build.return_value = timezonetest[0]
result = BaseTimeBuilder._build_object(timezonetest[0])
self.assertEqual(result, timezonetest[0])
mock_build.assert_called_once_with(**timezonetest[1])
def test_range_check_date(self):
#Check the calendar for day ranges
with self.assertRaises(DayOutOfBoundsError):
BaseTimeBuilder.range_check_date(YYYY='0007', MM='02', DD='30')
with self.assertRaises(DayOutOfBoundsError):
BaseTimeBuilder.range_check_date(YYYY='0007', DDD='366')
with self.assertRaises(MonthOutOfBoundsError):
BaseTimeBuilder.range_check_date(YYYY='4333', MM='30', DD='30')
#0 isn't a valid week number
with self.assertRaises(WeekOutOfBoundsError):
BaseTimeBuilder.range_check_date(YYYY='2003', Www='00')
#Week must not be larger than 53
with self.assertRaises(WeekOutOfBoundsError):
BaseTimeBuilder.range_check_date(YYYY='2004', Www='54')
#0 isn't a valid day number
with self.assertRaises(DayOutOfBoundsError):
BaseTimeBuilder.range_check_date(YYYY='2001', Www='02', D='0')
#Day must not be larger than 7
with self.assertRaises(DayOutOfBoundsError):
BaseTimeBuilder.range_check_date(YYYY='2001', Www='02', D='8')
with self.assertRaises(DayOutOfBoundsError):
BaseTimeBuilder.range_check_date(YYYY='1981', DDD='000')
#Day must be 365, or 366, not larger
with self.assertRaises(DayOutOfBoundsError):
BaseTimeBuilder.range_check_date(YYYY='1234', DDD='000')
with self.assertRaises(DayOutOfBoundsError):
BaseTimeBuilder.range_check_date(YYYY='1234', DDD='367')
#https://bitbucket.org/nielsenb/aniso8601/issues/14/parsing-ordinal-dates-should-only-allow
with self.assertRaises(DayOutOfBoundsError):
BaseTimeBuilder.range_check_date(YYYY='1981', DDD='366')
#Make sure Nones pass through unmodified
self.assertEqual(BaseTimeBuilder.range_check_date(rangedict={}),
(None, None, None, None, None, None))
def test_range_check_time(self):
# Leap seconds not supported
# https://bitbucket.org/nielsenb/aniso8601/issues/10/sub-microsecond-precision-in-durations-is
# https://bitbucket.org/nielsenb/aniso8601/issues/13/parsing-of-leap-second-gives-wildly
with self.assertRaises(LeapSecondError):
BaseTimeBuilder.range_check_time(hh="23", mm="59", ss="60")
with self.assertRaises(SecondsOutOfBoundsError):
BaseTimeBuilder.range_check_time(hh="00", mm="00", ss="60")
with self.assertRaises(SecondsOutOfBoundsError):
BaseTimeBuilder.range_check_time(hh="00", mm="00", ss="61")
with self.assertRaises(MinutesOutOfBoundsError):
BaseTimeBuilder.range_check_time(hh="00", mm="61")
with self.assertRaises(MinutesOutOfBoundsError):
BaseTimeBuilder.range_check_time(hh="00", mm="60")
with self.assertRaises(MinutesOutOfBoundsError):
BaseTimeBuilder.range_check_time(hh="00", mm="60.1")
with self.assertRaises(HoursOutOfBoundsError):
BaseTimeBuilder.range_check_time(hh="25")
# Hour 24 can only represent midnight
with self.assertRaises(MidnightBoundsError):
BaseTimeBuilder.range_check_time(hh="24", mm="00", ss="01")
with self.assertRaises(MidnightBoundsError):
BaseTimeBuilder.range_check_time(hh="24", mm="00.1")
with self.assertRaises(MidnightBoundsError):
BaseTimeBuilder.range_check_time(hh="24", mm="01")
with self.assertRaises(MidnightBoundsError):
BaseTimeBuilder.range_check_time(hh="24.1")
# Leap seconds not supported
# https://bitbucket.org/nielsenb/aniso8601/issues/10/sub-microsecond-precision-in-durations-is
# https://bitbucket.org/nielsenb/aniso8601/issues/13/parsing-of-leap-second-gives-wildly
with self.assertRaises(LeapSecondError):
BaseTimeBuilder.range_check_time(hh="23", mm="59", ss="60")
# Make sure Nones pass through unmodified
self.assertEqual(BaseTimeBuilder.range_check_time(rangedict={}),
(None, None, None, None))
def range_check_duration(cls,
PnY=None,
PnM=None,
PnW=None,
PnD=None,
TnH=None,
TnM=None,
TnS=None,
rangedict=None):
years = 0
months = 0
days = 0
weeks = 0
hours = 0
minutes = 0
seconds = 0
microseconds = 0
PnY, PnM, PnW, PnD, TnH, TnM, TnS = BaseTimeBuilder.range_check_duration(
PnY,
PnM,
PnW,
PnD,
TnH,
TnM,
TnS,
rangedict=cls.DURATION_RANGE_DICT)
if PnY is not None:
if type(PnY) is FractionalComponent:
years = PnY.principal
microseconds = PnY.microsecondremainder
else:
years = PnY
if years * DAYS_PER_YEAR > TIMEDELTA_MAX_DAYS:
raise YearOutOfBoundsError(
'Duration exceeds maximum timedelta size.')
if PnM is not None:
if type(PnM) is FractionalComponent:
months = PnM.principal
microseconds = PnM.microsecondremainder
else:
months = PnM
if months * DAYS_PER_MONTH > TIMEDELTA_MAX_DAYS:
raise MonthOutOfBoundsError(
'Duration exceeds maximum timedelta size.')
if PnW is not None:
if type(PnW) is FractionalComponent:
weeks = PnW.principal
microseconds = PnW.microsecondremainder
else:
weeks = PnW
if weeks * DAYS_PER_WEEK > TIMEDELTA_MAX_DAYS:
raise WeekOutOfBoundsError(
'Duration exceeds maximum timedelta size.')
if PnD is not None:
if type(PnD) is FractionalComponent:
days = PnD.principal
microseconds = PnD.microsecondremainder
else:
days = PnD
if days > TIMEDELTA_MAX_DAYS:
raise DayOutOfBoundsError(
'Duration exceeds maximum timedelta size.')
if TnH is not None:
if type(TnH) is FractionalComponent:
hours = TnH.principal
microseconds = TnH.microsecondremainder
else:
hours = TnH
if hours // HOURS_PER_DAY > TIMEDELTA_MAX_DAYS:
raise HoursOutOfBoundsError(
'Duration exceeds maximum timedelta size.')
if TnM is not None:
if type(TnM) is FractionalComponent:
minutes = TnM.principal
microseconds = TnM.microsecondremainder
else:
minutes = TnM
if minutes // MINUTES_PER_DAY > TIMEDELTA_MAX_DAYS:
raise MinutesOutOfBoundsError(
'Duration exceeds maximum timedelta size.')
if TnS is not None:
if type(TnS) is FractionalComponent:
seconds = TnS.principal
microseconds = TnS.microsecondremainder
else:
seconds = TnS
if seconds // SECONDS_PER_DAY > TIMEDELTA_MAX_DAYS:
raise SecondsOutOfBoundsError(
'Duration exceeds maximum timedelta size.')
years, months, weeks, days, hours, minutes, seconds, microseconds = PythonTimeBuilder._distribute_microseconds(
microseconds,
(years, months, weeks, days, hours, minutes, seconds),
(MICROSECONDS_PER_YEAR, MICROSECONDS_PER_MONTH,
MICROSECONDS_PER_WEEK, MICROSECONDS_PER_DAY,
MICROSECONDS_PER_HOUR, MICROSECONDS_PER_MINUTE,
MICROSECONDS_PER_SECOND))
#Note that weeks can be handled without conversion to days
totaldays = years * DAYS_PER_YEAR + months * DAYS_PER_MONTH + days
#Check against timedelta limits
if totaldays + weeks * DAYS_PER_WEEK + hours // HOURS_PER_DAY + minutes // MINUTES_PER_DAY + seconds // SECONDS_PER_DAY > TIMEDELTA_MAX_DAYS:
raise DayOutOfBoundsError(
'Duration exceeds maximum timedelta size.')
return (None, None, weeks, totaldays, hours, minutes,
FractionalComponent(seconds, microseconds))
def test_range_check_date(self):
# Check the calendar for day ranges
with self.assertRaises(DayOutOfBoundsError):
BaseTimeBuilder.range_check_date(YYYY="0007", MM="02", DD="30")
with self.assertRaises(DayOutOfBoundsError):
BaseTimeBuilder.range_check_date(YYYY="0007", DDD="366")
with self.assertRaises(MonthOutOfBoundsError):
BaseTimeBuilder.range_check_date(YYYY="4333", MM="30", DD="30")
# 0 isn't a valid week number
with self.assertRaises(WeekOutOfBoundsError):
BaseTimeBuilder.range_check_date(YYYY="2003", Www="00")
# Week must not be larger than 53
with self.assertRaises(WeekOutOfBoundsError):
BaseTimeBuilder.range_check_date(YYYY="2004", Www="54")
# 0 isn't a valid day number
with self.assertRaises(DayOutOfBoundsError):
BaseTimeBuilder.range_check_date(YYYY="2001", Www="02", D="0")
# Day must not be larger than 7
with self.assertRaises(DayOutOfBoundsError):
BaseTimeBuilder.range_check_date(YYYY="2001", Www="02", D="8")
with self.assertRaises(DayOutOfBoundsError):
BaseTimeBuilder.range_check_date(YYYY="1981", DDD="000")
# Day must be 365, or 366, not larger
with self.assertRaises(DayOutOfBoundsError):
BaseTimeBuilder.range_check_date(YYYY="1234", DDD="000")
with self.assertRaises(DayOutOfBoundsError):
BaseTimeBuilder.range_check_date(YYYY="1234", DDD="367")
# https://bitbucket.org/nielsenb/aniso8601/issues/14/parsing-ordinal-dates-should-only-allow
with self.assertRaises(DayOutOfBoundsError):
BaseTimeBuilder.range_check_date(YYYY="1981", DDD="366")
# Make sure Nones pass through unmodified
self.assertEqual(
BaseTimeBuilder.range_check_date(rangedict={}),
(None, None, None, None, None, None),
)
def test_combine_concise_interval_tuples(self):
testtuples = (
(
DateTuple("2020", "01", "01", None, None, None),
DateTuple(None, None, "02", None, None, None),
DateTuple("2020", "01", "02", None, None, None),
),
(
DateTuple("2008", "02", "15", None, None, None),
DateTuple(None, "03", "14", None, None, None),
DateTuple("2008", "03", "14", None, None, None),
),
(
DatetimeTuple(
DateTuple("2007", "12", "14", None, None, None),
TimeTuple("13", "30", None, None),
),
TimeTuple("15", "30", None, None),
DatetimeTuple(
DateTuple("2007", "12", "14", None, None, None),
TimeTuple("15", "30", None, None),
),
),
(
DatetimeTuple(
DateTuple("2007", "11", "13", None, None, None),
TimeTuple("09", "00", None, None),
),
DatetimeTuple(
DateTuple(None, None, "15", None, None, None),
TimeTuple("17", "00", None, None),
),
DatetimeTuple(
DateTuple("2007", "11", "15", None, None, None),
TimeTuple("17", "00", None, None),
),
),
(
DatetimeTuple(
DateTuple("2007", "11", "13", None, None, None),
TimeTuple("00", "00", None, None),
),
DatetimeTuple(
DateTuple(None, None, "16", None, None, None),
TimeTuple("00", "00", None, None),
),
DatetimeTuple(
DateTuple("2007", "11", "16", None, None, None),
TimeTuple("00", "00", None, None),
),
),
(
DatetimeTuple(
DateTuple("2007", "11", "13", None, None, None),
TimeTuple("09", "00", None,
TimezoneTuple(False, True, None, None, "Z")),
),
DatetimeTuple(
DateTuple(None, None, "15", None, None, None),
TimeTuple("17", "00", None, None),
),
DatetimeTuple(
DateTuple("2007", "11", "15", None, None, None),
TimeTuple("17", "00", None,
TimezoneTuple(False, True, None, None, "Z")),
),
),
)
for testtuple in testtuples:
result = BaseTimeBuilder._combine_concise_interval_tuples(
testtuple[0], testtuple[1])
self.assertEqual(result, testtuple[2])
