Why Gemfury?
Push, build, and install
RubyGems
npm packages
Python packages
Maven artifacts
PHP packages
Go Modules
Bower components
Debian packages
RPM packages
NuGet packages
# -*- coding: utf-8 -*-
# Copyright (c) 2019, Brandon Nielsen
# All rights reserved.
#
# This software may be modified and distributed under the terms
# of the BSD license. See the LICENSE file for details.
import datetime
import unittest
from aniso8601 import compat
from aniso8601.exceptions import (DayOutOfBoundsError, HoursOutOfBoundsError,
ISOFormatError, LeapSecondError,
MidnightBoundsError, MinutesOutOfBoundsError,
SecondsOutOfBoundsError,
WeekOutOfBoundsError, YearOutOfBoundsError)
from aniso8601.builders.python import PythonTimeBuilder
from aniso8601.utcoffset import UTCOffset
class TestPythonTimeBuilder(unittest.TestCase):
def test_build_date(self):
testtuples = (({'YYYY': '2013', 'MM': None, 'DD': None, 'Www': None,
'D': None, 'DDD': None},
datetime.date(2013, 1, 1)),
({'YYYY': '0001', 'MM': None, 'DD': None, 'Www': None,
'D': None, 'DDD': None},
datetime.date(1, 1, 1)),
({'YYYY': '1900', 'MM': None, 'DD': None, 'Www': None,
'D': None, 'DDD': None},
datetime.date(1900, 1, 1)),
({'YYYY': '1981', 'MM': '04', 'DD': '05', 'Www': None,
'D': None, 'DDD': None},
datetime.date(1981, 4, 5)),
({'YYYY': '1981', 'MM': '04', 'DD': None, 'Www': None,
'D': None, 'DDD': None},
datetime.date(1981, 4, 1)),
({'YYYY': '1981', 'MM': None, 'DD': None, 'Www': None,
'D': None, 'DDD': '095'},
datetime.date(1981, 4, 5)),
({'YYYY': '1981', 'MM': None, 'DD': None, 'Www': None,
'D': None, 'DDD': '365'},
datetime.date(1981, 12, 31)),
({'YYYY': '1980', 'MM': None, 'DD': None, 'Www': None,
'D': None, 'DDD': '366'},
datetime.date(1980, 12, 31)),
#Make sure we shift in zeros
({'YYYY': '1', 'MM': None, 'DD': None, 'Www': None,
'D': None, 'DDD': None},
datetime.date(1000, 1, 1)),
({'YYYY': '12', 'MM': None, 'DD': None, 'Www': None,
'D': None, 'DDD': None},
datetime.date(1200, 1, 1)),
({'YYYY': '123', 'MM': None, 'DD': None, 'Www': None,
'D': None, 'DDD': None},
datetime.date(1230, 1, 1)))
for testtuple in testtuples:
result = PythonTimeBuilder.build_date(**testtuple[0])
self.assertEqual(result, testtuple[1])
#Test weekday
testtuples = (({'YYYY': '2004', 'MM': None, 'DD': None, 'Www': '53',
'D': None, 'DDD': None},
datetime.date(2004, 12, 27), 0),
({'YYYY': '2009', 'MM': None, 'DD': None, 'Www': '01',
'D': None, 'DDD': None},
datetime.date(2008, 12, 29), 0),
({'YYYY': '2010', 'MM': None, 'DD': None, 'Www': '01',
'D': None, 'DDD': None},
datetime.date(2010, 1, 4), 0),
({'YYYY': '2009', 'MM': None, 'DD': None, 'Www': '53',
'D': None, 'DDD': None},
datetime.date(2009, 12, 28), 0),
({'YYYY': '2009', 'MM': None, 'DD': None, 'Www': '01',
'D': '1', 'DDD': None},
datetime.date(2008, 12, 29), 0),
({'YYYY': '2009', 'MM': None, 'DD': None, 'Www': '53',
'D': '7', 'DDD': None},
datetime.date(2010, 1, 3), 6),
({'YYYY': '2010', 'MM': None, 'DD': None, 'Www': '01',
'D': '1', 'DDD': None},
datetime.date(2010, 1, 4), 0),
({'YYYY': '2004', 'MM': None, 'DD': None, 'Www': '53',
'D': '6', 'DDD': None},
datetime.date(2005, 1, 1), 5))
for testtuple in testtuples:
result = PythonTimeBuilder.build_date(**testtuple[0])
self.assertEqual(result, testtuple[1])
self.assertEqual(result.weekday(), testtuple[2])
def test_build_date_bounds_checking(self):
#0 isn't a valid week number
with self.assertRaises(WeekOutOfBoundsError):
PythonTimeBuilder.build_date(YYYY='2003', Www='00')
#Week must not be larger than 53
with self.assertRaises(WeekOutOfBoundsError):
PythonTimeBuilder.build_date(YYYY='2004', Www='54')
#0 isn't a valid day number
with self.assertRaises(DayOutOfBoundsError):
PythonTimeBuilder.build_date(YYYY='2001', Www='02', D='0')
#Day must not be larger than 7
with self.assertRaises(DayOutOfBoundsError):
PythonTimeBuilder.build_date(YYYY='2001', Www='02', D='8')
#0 isn't a valid year for a Python builder
with self.assertRaises(YearOutOfBoundsError):
PythonTimeBuilder.build_date(YYYY='0000')
with self.assertRaises(DayOutOfBoundsError):
PythonTimeBuilder.build_date(YYYY='1981', DDD='000')
#Day 366 is only valid on a leap year
with self.assertRaises(DayOutOfBoundsError):
PythonTimeBuilder.build_date(YYYY='1981', DDD='366')
#Day must me 365, or 366, not larger
with self.assertRaises(DayOutOfBoundsError):
PythonTimeBuilder.build_date(YYYY='1981', DDD='367')
def test_build_time(self):
testtuples = (({}, datetime.time()),
({'hh': '12.5'},
datetime.time(hour=12, minute=30)),
({'hh': '23.99999999997'},
datetime.time(hour=23, minute=59, second=59,
microsecond=999999)),
({'hh': '1', 'mm': '23'},
datetime.time(hour=1, minute=23)),
({'hh': '1', 'mm': '23.4567'},
datetime.time(hour=1, minute=23, second=27,
microsecond=402000)),
({'hh': '14', 'mm': '43.999999997'},
datetime.time(hour=14, minute=43, second=59,
microsecond=999999)),
({'hh': '1', 'mm': '23', 'ss': '45'},
datetime.time(hour=1, minute=23, second=45)),
({'hh': '23', 'mm': '21', 'ss': '28.512400'},
datetime.time(hour=23, minute=21, second=28,
microsecond=512400)),
({'hh': '01', 'mm': '03', 'ss': '11.858714'},
datetime.time(hour=1, minute=3, second=11,
microsecond=858714)),
({'hh': '14', 'mm': '43', 'ss': '59.9999997'},
datetime.time(hour=14, minute=43, second=59,
microsecond=999999)),
({'hh': '24'}, datetime.time(hour=0)),
({'hh': '24', 'mm': '00'}, datetime.time(hour=0)),
({'hh': '24', 'mm': '00', 'ss': '00'},
datetime.time(hour=0)),
({'tz': (False, None, '00', '00', 'UTC', 'timezone')},
datetime.time(tzinfo=UTCOffset(name='UTC', minutes=0))),
({'hh': '23', 'mm': '21', 'ss': '28.512400',
'tz': (False, None, '00', '00', '+00:00', 'timezone')},
datetime.time(hour=23, minute=21, second=28,
microsecond=512400,
tzinfo=UTCOffset(name='+00:00',
minutes=0))),
({'hh': '1', 'mm': '23',
'tz': (False, None, '01', '00', '+1', 'timezone')},
datetime.time(hour=1, minute=23,
tzinfo=UTCOffset(name='+1',
minutes=60))),
({'hh': '1', 'mm': '23.4567',
'tz': (True, None, '01', '00', '-1', 'timezone')},
datetime.time(hour=1, minute=23, second=27,
microsecond=402000,
tzinfo=UTCOffset(name='-1',
minutes=-60))),
({'hh': '23', 'mm': '21', 'ss': '28.512400',
'tz': (False, None, '01', '30', '+1:30', 'timezone')},
datetime.time(hour=23, minute=21, second=28,
microsecond=512400,
tzinfo=UTCOffset(name='+1:30',
minutes=90))),
({'hh': '23', 'mm': '21', 'ss': '28.512400',
'tz': (False, None, '11', '15', '+11:15', 'timezone')},
datetime.time(hour=23, minute=21, second=28,
microsecond=512400,
tzinfo=UTCOffset(name='+11:15',
minutes=675))),
({'hh': '23', 'mm': '21', 'ss': '28.512400',
'tz': (False, None, '12', '34', '+12:34', 'timezone')},
datetime.time(hour=23, minute=21, second=28,
microsecond=512400,
tzinfo=UTCOffset(name='+12:34',
minutes=754))),
({'hh': '23', 'mm': '21', 'ss': '28.512400',
'tz': (False, None, '00', '00', 'UTC', 'timezone')},
datetime.time(hour=23, minute=21, second=28,
microsecond=512400,
tzinfo=UTCOffset(name='UTC',
minutes=0))),
#Make sure we truncate, not round
#https://bitbucket.org/nielsenb/aniso8601/issues/10/sub-microsecond-precision-in-durations-is
#https://bitbucket.org/nielsenb/aniso8601/issues/21/sub-microsecond-precision-is-lost-when
({'hh': '14.9999999999999999'},
datetime.time(hour=14, minute=59, second=59,
microsecond=999999)),
({'mm': '0.00000000999'},
datetime.time()),
({'mm': '0.0000000999'},
datetime.time(microsecond=5)),
({'ss': '0.0000001'},
datetime.time()),
({'ss': '2.0000048'},
datetime.time(second=2,
microsecond=4)))
for testtuple in testtuples:
result = PythonTimeBuilder.build_time(**testtuple[0])
self.assertEqual(result, testtuple[1])
def test_build_time_bounds_checking(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):
PythonTimeBuilder.build_time(hh='23', mm='59', ss='60')
with self.assertRaises(LeapSecondError):
PythonTimeBuilder.build_time(hh='23', mm='59', ss='60',
tz=UTCOffset(name='UTC', minutes=0))
with self.assertRaises(SecondsOutOfBoundsError):
PythonTimeBuilder.build_time(hh='00', mm='00', ss='60')
with self.assertRaises(SecondsOutOfBoundsError):
PythonTimeBuilder.build_time(hh='00', mm='00', ss='60',
tz=UTCOffset(name='UTC', minutes=0))
with self.assertRaises(SecondsOutOfBoundsError):
PythonTimeBuilder.build_time(hh='00', mm='00', ss='61')
with self.assertRaises(SecondsOutOfBoundsError):
PythonTimeBuilder.build_time(hh='00', mm='00', ss='61',
tz=UTCOffset(name='UTC', minutes=0))
with self.assertRaises(MinutesOutOfBoundsError):
PythonTimeBuilder.build_time(hh='00', mm='61')
with self.assertRaises(MinutesOutOfBoundsError):
PythonTimeBuilder.build_time(hh='00', mm='61',
tz=UTCOffset(name='UTC', minutes=0))
with self.assertRaises(MinutesOutOfBoundsError):
PythonTimeBuilder.build_time(hh='00', mm='60')
with self.assertRaises(MinutesOutOfBoundsError):
PythonTimeBuilder.build_time(hh='00', mm='60.1')
with self.assertRaises(HoursOutOfBoundsError):
PythonTimeBuilder.build_time(hh='25')
#Hour 24 can only represent midnight
with self.assertRaises(MidnightBoundsError):
PythonTimeBuilder.build_time(hh='24', mm='00', ss='01')
with self.assertRaises(MidnightBoundsError):
PythonTimeBuilder.build_time(hh='24', mm='00.1')
with self.assertRaises(MidnightBoundsError):
PythonTimeBuilder.build_time(hh='24', mm='01')
with self.assertRaises(MidnightBoundsError):
PythonTimeBuilder.build_time(hh='24.1')
def test_build_datetime(self):
testtuples = (((('2019', '06', '05', None, None, None, 'date'),
('01', '03', '11.858714', None, 'time')),
datetime.datetime(2019, 6, 5, hour=1, minute=3,
second=11, microsecond=858714)),
((('1234', '02', '03', None, None, None, 'date'),
('23', '21', '28.512400', None, 'time')),
datetime.datetime(1234, 2, 3, hour=23, minute=21,
second=28, microsecond=512400)),
((('1981', '04', '05', None, None, None, 'date'),
('23', '21', '28.512400',
(False, None, '11', '15', '+11:15', 'timezone'),
'time')),
datetime.datetime(1981, 4, 5, hour=23, minute=21,
second=28, microsecond=512400,
tzinfo=UTCOffset(name='+11:15',
minutes=675))))
for testtuple in testtuples:
result = PythonTimeBuilder.build_datetime(*testtuple[0])
self.assertEqual(result, testtuple[1])
def test_build_datetime_bounds_checking(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):
PythonTimeBuilder.build_datetime(('2016', '12', '31',
None, None, None, 'date'),
('23', '59', '60', None, 'time'))
with self.assertRaises(LeapSecondError):
PythonTimeBuilder.build_datetime(('2016', '12', '31',
None, None, None, 'date'),
('23', '59', '60',
(False, None, '00', '00',
'+00:00', 'timezone'), 'time'))
with self.assertRaises(SecondsOutOfBoundsError):
PythonTimeBuilder.build_datetime(('1981', '04', '05',
None, None, None, 'date'),
('00', '00', '60', None, 'time'))
with self.assertRaises(SecondsOutOfBoundsError):
PythonTimeBuilder.build_datetime(('1981', '04', '05',
None, None, None, 'date'),
('00', '00', '60',
(False, None, '00', '00',
'+00:00', 'timezone'), 'time'))
with self.assertRaises(SecondsOutOfBoundsError):
PythonTimeBuilder.build_datetime(('1981', '04', '05',
None, None, None, 'date'),
('00', '00', '61', None, 'time'))
with self.assertRaises(SecondsOutOfBoundsError):
PythonTimeBuilder.build_datetime(('1981', '04', '05',
None, None, None, 'date'),
('00', '00', '61',
(False, None, '00', '00',
'+00:00', 'timezone'), 'time'))
with self.assertRaises(SecondsOutOfBoundsError):
PythonTimeBuilder.build_datetime(('1981', '04', '05',
None, None, None, 'date'),
('00', '59', '61', None, 'time'))
with self.assertRaises(SecondsOutOfBoundsError):
PythonTimeBuilder.build_datetime(('1981', '04', '05',
None, None, None, 'date'),
('00', '59', '61',
(False, None, '00', '00',
'+00:00', 'timezone'), 'time'))
with self.assertRaises(MinutesOutOfBoundsError):
PythonTimeBuilder.build_datetime(('1981', '04', '05',
None, None, None, 'date'),
('00', '61', None, None, 'time'))
with self.assertRaises(MinutesOutOfBoundsError):
PythonTimeBuilder.build_datetime(('1981', '04', '05',
None, None, None, 'date'),
('00', '61', None,
(False, None, '00', '00',
'+00:00', 'timezone'), 'time'))
def test_build_duration(self):
testtuples = (({'PnY': '1', 'PnM': '2', 'PnD': '3',
'TnH': '4', 'TnM': '54', 'TnS': '6'},
datetime.timedelta(days=428, hours=4,
minutes=54, seconds=6)),
({'PnY': '1', 'PnM': '2', 'PnD': '3',
'TnH': '4', 'TnM': '54', 'TnS': '6.5'},
datetime.timedelta(days=428, hours=4,
minutes=54, seconds=6.5)),
({'PnY': '1', 'PnM': '2', 'PnD': '3'},
datetime.timedelta(days=428)),
({'PnY': '1', 'PnM': '2', 'PnD': '3.5'},
datetime.timedelta(days=428.5)),
({'TnH': '4', 'TnM': '54', 'TnS': '6.5'},
datetime.timedelta(hours=4, minutes=54, seconds=6.5)),
({'TnH': '1', 'TnM': '3', 'TnS': '11.858714'},
datetime.timedelta(hours=1, minutes=3,
seconds=11, microseconds=858714)),
({'TnH': '4', 'TnM': '54', 'TnS': '28.512400'},
datetime.timedelta(hours=4, minutes=54,
seconds=28, microseconds=512400)),
#Make sure we truncate, not round
#https://bitbucket.org/nielsenb/aniso8601/issues/10/sub-microsecond-precision-in-durations-is
#https://bitbucket.org/nielsenb/aniso8601/issues/21/sub-microsecond-precision-is-lost-when
({'PnY': '1999.9999999999999999'},
datetime.timedelta(days=729999, seconds=86399,
microseconds=999999)),
({'PnM': '1.9999999999999999'},
datetime.timedelta(days=59, hours=23,
minutes=59, seconds=59,
microseconds=999999)),
({'PnW': '1.9999999999999999'},
datetime.timedelta(days=13, hours=23,
minutes=59, seconds=59,
microseconds=999999)),
({'PnD': '1.9999999999999999'},
datetime.timedelta(days=1, hours=23,
minutes=59, seconds=59,
microseconds=999999)),
({'TnH': '14.9999999999999999'},
datetime.timedelta(hours=14, minutes=59,
seconds=59, microseconds=999999)),
({'TnM': '0.00000000999'}, datetime.timedelta(0)),
({'TnM': '0.0000000999'},
datetime.timedelta(microseconds=5)),
({'TnS': '0.0000001'}, datetime.timedelta(0)),
({'TnS': '2.0000048'},
datetime.timedelta(seconds=2, microseconds=4)),
({'PnY': '1'}, datetime.timedelta(days=365)),
({'PnY': '1.5'}, datetime.timedelta(days=547.5)),
({'PnM': '1'}, datetime.timedelta(days=30)),
({'PnM': '1.5'}, datetime.timedelta(days=45)),
({'PnW': '1'}, datetime.timedelta(days=7)),
({'PnW': '1.5'}, datetime.timedelta(days=10.5)),
({'PnD': '1'}, datetime.timedelta(days=1)),
({'PnD': '1.5'}, datetime.timedelta(days=1.5)),
({'PnY': '0003', 'PnM': '06', 'PnD': '04',
'TnH': '12', 'TnM': '30', 'TnS': '05'},
datetime.timedelta(days=1279, hours=12,
minutes=30, seconds=5)),
({'PnY': '0003', 'PnM': '06', 'PnD': '04',
'TnH': '12', 'TnM': '30', 'TnS': '05.5'},
datetime.timedelta(days=1279, hours=12,
minutes=30, seconds=5.5)),
#Make sure we truncate, not round
#https://bitbucket.org/nielsenb/aniso8601/issues/10/sub-microsecond-precision-in-durations-is
({'PnY': '0001', 'PnM': '02', 'PnD': '03',
'TnH': '14', 'TnM': '43', 'TnS': '59.9999997'},
datetime.timedelta(days=428, hours=14,
minutes=43, seconds=59,
microseconds=999999)),
#Verify overflows
({'TnH': '36'}, datetime.timedelta(days=1, hours=12)))
for testtuple in testtuples:
result = PythonTimeBuilder.build_duration(**testtuple[0])
self.assertEqual(result, testtuple[1])
def test_build_interval(self):
testtuples = (({'end': (('1981', '04', '05', None, None, None, 'date'),
('01', '01', '00', None, 'time'), 'datetime'),
'duration': (None, '1', None, None, None, None, None,
'duration')},
datetime.datetime(year=1981, month=4, day=5,
hour=1, minute=1),
datetime.datetime(year=1981, month=3, day=6,
hour=1, minute=1)),
({'end': ('1981', '04', '05', None, None, None, 'date'),
'duration': (None, '1', None, None, None, None, None,
'duration')},
datetime.date(year=1981, month=4, day=5),
datetime.date(year=1981, month=3, day=6)),
({'end': ('2018', '03', '06', None, None, None, 'date'),
'duration': ('1.5', None, None, None, None, None, None,
'duration')},
datetime.date(year=2018, month=3, day=6),
datetime.datetime(year=2016, month=9, day=4,
hour=12)),
({'end': ('2014', '11', '12', None, None, None, 'date'),
'duration': (None, None, None, None, '1', None, None,
'duration')},
datetime.date(year=2014, month=11, day=12),
datetime.datetime(year=2014, month=11, day=11,
hour=23)),
({'end': ('2014', '11', '12', None, None, None, 'date'),
'duration': (None, None, None, None, '4', '54', '6.5',
'duration')},
datetime.date(year=2014, month=11, day=12),
datetime.datetime(year=2014, month=11, day=11,
hour=19, minute=5, second=53,
microsecond=500000)),
({'end': (('2050', '03', '01',
None, None, None, 'date'),
('13', '00', '00',
(False, True, None, None,
'Z', 'timezone'), 'time'), 'datetime'),
'duration': (None, None, None,
None, '10', None, None, 'duration')},
datetime.datetime(year=2050, month=3, day=1,
hour=13,
tzinfo=UTCOffset(name='UTC',
minutes=0)),
datetime.datetime(year=2050, month=3, day=1,
hour=3,
tzinfo=UTCOffset(name='UTC',
minutes=0))),
#Make sure we truncate, not round
#https://bitbucket.org/nielsenb/aniso8601/issues/10/sub-microsecond-precision-in-durations-is
#https://bitbucket.org/nielsenb/aniso8601/issues/21/sub-microsecond-precision-is-lost-when
({'end': ('2000', '01', '01',
None, None, None, 'date'),
'duration': ('1999.9999999999999999', None, None,
None, None, None,
None, 'duration')},
datetime.date(year=2000, month=1, day=1),
datetime.datetime(year=1, month=4, day=30,
hour=0, minute=0, second=0,
microsecond=1)),
({'end': ('1989', '03', '01',
None, None, None, 'date'),
'duration': (None, '1.9999999999999999', None,
None, None, None,
None, 'duration')},
datetime.date(year=1989, month=3, day=1),
datetime.datetime(year=1988, month=12, day=31,
hour=0, minute=0, second=0,
microsecond=1)),
({'end': ('1989', '03', '01',
None, None, None, 'date'),
'duration': (None, None, '1.9999999999999999',
None, None, None,
None, 'duration')},
datetime.date(year=1989, month=3, day=1),
datetime.datetime(year=1989, month=2, day=15,
hour=0, minute=0, second=0,
microsecond=1)),
({'end': ('1989', '03', '01',
None, None, None, 'date'),
'duration': (None, None, None,
'1.9999999999999999', None, None,
None, 'duration')},
datetime.date(year=1989, month=3, day=1),
datetime.datetime(year=1989, month=2, day=27,
hour=0, minute=0, second=0,
microsecond=1)),
({'end': ('2001', '01', '01',
None, None, None, 'date'),
'duration': (None, None, None,
None, '14.9999999999999999', None,
None, 'duration')},
datetime.date(year=2001, month=1, day=1),
datetime.datetime(year=2000, month=12, day=31,
hour=9, minute=0, second=0,
microsecond=1)),
({'end': ('2001', '01', '01',
None, None, None, 'date'),
'duration': (None, None, None,
None, None, '0.00000000999',
None, 'duration')},
datetime.date(year=2001, month=1, day=1),
datetime.datetime(year=2001, month=1, day=1)),
({'end': ('2001', '01', '01',
None, None, None, 'date'),
'duration': (None, None, None,
None, None, '0.0000000999',
None, 'duration')},
datetime.date(year=2001, month=1, day=1),
datetime.datetime(year=2000, month=12, day=31,
hour=23, minute=59, second=59,
microsecond=999995)),
({'end': ('2018', '03', '06', None, None, None, 'date'),
'duration': (None, None, None,
None, None, None,
'0.0000001', 'duration')},
datetime.date(year=2018, month=3, day=6),
datetime.datetime(year=2018, month=3, day=6)),
({'end': ('2018', '03', '06', None, None, None, 'date'),
'duration': (None, None, None,
None, None, None,
'2.0000048', 'duration')},
datetime.date(year=2018, month=3, day=6),
datetime.datetime(year=2018, month=3, day=5,
hour=23, minute=59, second=57,
microsecond=999996)),
({'start': (('1981', '04', '05',
None, None, None, 'date'),
('01', '01', '00', None, 'time'),
'datetime'),
'duration': (None, '1', None,
'1', None, '1', None, 'duration')},
datetime.datetime(year=1981, month=4, day=5,
hour=1, minute=1),
datetime.datetime(year=1981, month=5, day=6,
hour=1, minute=2)),
({'start': ('1981', '04', '05',
None, None, None, 'date'),
'duration': (None, '1', None,
'1', None, None, None, 'duration')},
datetime.date(year=1981, month=4, day=5),
datetime.date(year=1981, month=5, day=6)),
({'start': ('2018', '03', '06',
None, None, None, 'date'),
'duration': (None, '2.5', None,
None, None, None, None, 'duration')},
datetime.date(year=2018, month=3, day=6),
datetime.date(year=2018, month=5, day=20)),
({'start': ('2014', '11', '12',
None, None, None, 'date'),
'duration': (None, None, None,
None, '1', None, None, 'duration')},
datetime.date(year=2014, month=11, day=12),
datetime.datetime(year=2014, month=11, day=12,
hour=1, minute=0)),
({'start': ('2014', '11', '12',
None, None, None, 'date'),
'duration': (None, None, None,
None, '4', '54', '6.5', 'duration')},
datetime.date(year=2014, month=11, day=12),
datetime.datetime(year=2014, month=11, day=12,
hour=4, minute=54, second=6,
microsecond=500000)),
({'start': (('2050', '03', '01',
None, None, None, 'date'),
('13', '00', '00',
(False, True, None, None,
'Z', 'timezone'), 'time'), 'datetime'),
'duration': (None, None, None,
None, '10', None, None, 'duration')},
datetime.datetime(year=2050, month=3, day=1,
hour=13,
tzinfo=UTCOffset(name='UTC',
minutes=0)),
datetime.datetime(year=2050, month=3, day=1,
hour=23,
tzinfo=UTCOffset(name='UTC',
minutes=0))),
#Make sure we truncate, not round
#https://bitbucket.org/nielsenb/aniso8601/issues/10/sub-microsecond-precision-in-durations-is
({'start': ('0001', '01', '01',
None, None, None, 'date'),
'duration': ('1999.9999999999999999', None, None,
None, None, None,
None, 'duration')},
datetime.date(year=1, month=1, day=1),
datetime.datetime(year=1999, month=9, day=3,
hour=23, minute=59, second=59,
microsecond=999999)),
({'start': ('1989', '03', '01',
None, None, None, 'date'),
'duration': (None, '1.9999999999999999', None,
None, None, None,
None, 'duration')},
datetime.date(year=1989, month=3, day=1),
datetime.datetime(year=1989, month=4, day=29,
hour=23, minute=59, second=59,
microsecond=999999)),
({'start': ('1989', '03', '01',
None, None, None, 'date'),
'duration': (None, None, '1.9999999999999999',
None, None, None,
None, 'duration')},
datetime.date(year=1989, month=3, day=1),
datetime.datetime(year=1989, month=3, day=14,
hour=23, minute=59, second=59,
microsecond=999999)),
({'start': ('1989', '03', '01',
None, None, None, 'date'),
'duration': (None, None, None,
'1.9999999999999999', None, None,
None, 'duration')},
datetime.date(year=1989, month=3, day=1),
datetime.datetime(year=1989, month=3, day=2,
hour=23, minute=59, second=59,
microsecond=999999)),
({'start': ('2001', '01', '01',
None, None, None, 'date'),
'duration': (None, None, None,
None, '14.9999999999999999', None,
None, 'duration')},
datetime.date(year=2001, month=1, day=1),
datetime.datetime(year=2001, month=1, day=1,
hour=14, minute=59, second=59,
microsecond=999999)),
({'start': ('2001', '01', '01',
None, None, None, 'date'),
'duration': (None, None, None,
None, None, '0.00000000999',
None, 'duration')},
datetime.date(year=2001, month=1, day=1),
datetime.datetime(year=2001, month=1, day=1)),
({'start': ('2001', '01', '01',
None, None, None, 'date'),
'duration': (None, None, None,
None, None, '0.0000000999',
None, 'duration')},
datetime.date(year=2001, month=1, day=1),
datetime.datetime(year=2001, month=1, day=1,
hour=0, minute=0, second=0,
microsecond=5)),
({'start': ('2018', '03', '06',
None, None, None, 'date'),
'duration': (None, None, None,
None, None, None,
'0.0000001', 'duration')},
datetime.date(year=2018, month=3, day=6),
datetime.datetime(year=2018, month=3, day=6)),
({'start': ('2018', '03', '06',
None, None, None, 'date'),
'duration': (None, None, None,
None, None, None,
'2.0000048', 'duration')},
datetime.date(year=2018, month=3, day=6),
datetime.datetime(year=2018, month=3, day=6,
hour=0, minute=0, second=2,
microsecond=4)),
({'start': (('1980', '03', '05',
None, None, None, 'date'),
('01', '01', '00',
None, 'time'), 'datetime'),
'end': (('1981', '04', '05',
None, None, None, 'date'),
('01', '01', '00',
None, 'time'), 'datetime')},
datetime.datetime(year=1980, month=3, day=5,
hour=1, minute=1),
datetime.datetime(year=1981, month=4, day=5,
hour=1, minute=1)),
({'start': (('1980', '03', '05',
None, None, None, 'date'),
('01', '01', '00',
None, 'time'), 'datetime'),
'end': ('1981', '04', '05',
None, None, None, 'date')},
datetime.datetime(year=1980, month=3, day=5,
hour=1, minute=1),
datetime.date(year=1981, month=4, day=5)),
({'start': ('1980', '03', '05',
None, None, None, 'date'),
'end': (('1981', '04', '05',
None, None, None, 'date'),
('01', '01', '00',
None, 'time'), 'datetime')},
datetime.date(year=1980, month=3, day=5),
datetime.datetime(year=1981, month=4, day=5,
hour=1, minute=1)),
({'start': ('1980', '03', '05',
None, None, None, 'date'),
'end': ('1981', '04', '05',
None, None, None, 'date')},
datetime.date(year=1980, month=3, day=5),
datetime.date(year=1981, month=4, day=5)),
({'start': ('1981', '04', '05',
None, None, None, 'date'),
'end': ('1980', '03', '05',
None, None, None, 'date')},
datetime.date(year=1981, month=4, day=5),
datetime.date(year=1980, month=3, day=5)),
({'start': (('2050', '03', '01',
None, None, None, 'date'),
('13', '00', '00',
(False, True, None, None,
'Z', 'timezone'), 'time'), 'datetime'),
'end': (('2050', '05', '11',
None, None, None, 'date'),
('15', '30', '00',
(False, True, None, None,
'Z', 'timezone'), 'time'), 'datetime')},
datetime.datetime(year=2050, month=3, day=1,
hour=13,
tzinfo=UTCOffset(name='UTC',
minutes=0)),
datetime.datetime(year=2050, month=5, day=11,
hour=15, minute=30,
tzinfo=UTCOffset(name='UTC',
minutes=0))),
#Make sure we truncate, not round
#https://bitbucket.org/nielsenb/aniso8601/issues/10/sub-microsecond-precision-in-durations-is
({'start': (('1980', '03', '05',
None, None, None, 'date'),
('01', '01', '00.0000001',
None, 'time'), 'datetime'),
'end': (('1981', '04', '05',
None, None, None, 'date'),
('14', '43', '59.9999997', None, 'time'),
'datetime')},
datetime.datetime(year=1980, month=3, day=5,
hour=1, minute=1),
datetime.datetime(year=1981, month=4, day=5,
hour=14, minute=43, second=59,
microsecond=999999)))
for testtuple in testtuples:
result = PythonTimeBuilder.build_interval(**testtuple[0])
self.assertEqual(result[0], testtuple[1])
self.assertEqual(result[1], testtuple[2])
def test_build_repeating_interval(self):
args = {'Rnn': '3', 'interval': (('1981', '04', '05',
None, None, None, 'date'),
None,
(None, None, None,
'1', None, None,
None, 'duration'),
'interval')}
results = list(PythonTimeBuilder.build_repeating_interval(**args))
self.assertEqual(results[0], datetime.date(year=1981, month=4, day=5))
self.assertEqual(results[1], datetime.date(year=1981, month=4, day=6))
self.assertEqual(results[2], datetime.date(year=1981, month=4, day=7))
args = {'Rnn': '11', 'interval': (None,
(('1980', '03', '05',
None, None, None, 'date'),
('01', '01', '00',
None, 'time'), 'datetime'),
(None, None, None,
None, '1', '2',
None, 'duration'),
'interval')}
results = list(PythonTimeBuilder.build_repeating_interval(**args))
for dateindex in compat.range(0, 11):
self.assertEqual(results[dateindex],
datetime.datetime(year=1980, month=3, day=5,
hour=1, minute=1)
- dateindex * datetime.timedelta(hours=1,
minutes=2))
args = {'Rnn': '2', 'interval': ((('1980', '03', '05',
None, None, None, 'date'),
('01', '01', '00',
None, 'time'), 'datetime'),
(('1981', '04', '05',
None, None, None, 'date'),
('01', '01', '00',
None, 'time'), 'datetime'),
None,
'interval')}
results = list(PythonTimeBuilder.build_repeating_interval(**args))
self.assertEqual(results[0],
datetime.datetime(year=1980, month=3, day=5,
hour=1, minute=1))
self.assertEqual(results[1],
datetime.datetime(year=1981, month=4, day=5,
hour=1, minute=1))
args = {'Rnn': '2', 'interval': ((('1980', '03', '05',
None, None, None, 'date'),
('01', '01', '00',
None, 'time'), 'datetime'),
(('1981', '04', '05',
None, None, None, 'date'),
('01', '01', '00',
None, 'time'), 'datetime'),
None,
'interval')}
results = list(PythonTimeBuilder.build_repeating_interval(**args))
self.assertEqual(results[0],
datetime.datetime(year=1980, month=3, day=5,
hour=1, minute=1))
self.assertEqual(results[1],
datetime.datetime(year=1981, month=4, day=5,
hour=1, minute=1))
args = {'R': True, 'interval': (None,
(('1980', '03', '05',
None, None, None, 'date'),
('01', '01', '00',
None, 'time'), 'datetime'),
(None, None, None,
None, '1', '2', None, 'duration'),
'interval')}
resultgenerator = PythonTimeBuilder.build_repeating_interval(**args)
#Test the first 11 generated
for dateindex in compat.range(0, 11):
self.assertEqual(next(resultgenerator),
datetime.datetime(year=1980, month=3, day=5,
hour=1, minute=1)
- dateindex * datetime.timedelta(hours=1,
minutes=2))
def test_build_timezone(self):
testtuples = (({'Z': True, 'name': 'Z'},
datetime.timedelta(hours=0), 'UTC'),
({'negative': False, 'hh': '00', 'mm': '00',
'name': '+00:00'},
datetime.timedelta(hours=0), '+00:00'),
({'negative': False, 'hh': '01', 'mm': '00',
'name': '+01:00'},
datetime.timedelta(hours=1), '+01:00'),
({'negative': True, 'hh': '01', 'mm': '00',
'name': '-01:00'},
-datetime.timedelta(hours=1), '-01:00'),
({'negative': False, 'hh': '00', 'mm': '12',
'name': '+00:12'},
datetime.timedelta(minutes=12), '+00:12'),
({'negative': False, 'hh': '01', 'mm': '23',
'name': '+01:23'},
datetime.timedelta(hours=1, minutes=23), '+01:23'),
({'negative': True, 'hh': '01', 'mm': '23',
'name': '-01:23'},
-datetime.timedelta(hours=1, minutes=23), '-01:23'),
({'negative': False, 'hh': '00',
'name': '+00'},
datetime.timedelta(hours=0), '+00'),
({'negative': False, 'hh': '01',
'name': '+01'},
datetime.timedelta(hours=1), '+01'),
({'negative': True, 'hh': '01',
'name': '-01'},
-datetime.timedelta(hours=1), '-01'),
({'negative': False, 'hh': '12',
'name': '+12'},
datetime.timedelta(hours=12), '+12'),
({'negative': True, 'hh': '12',
'name': '-12'},
-datetime.timedelta(hours=12), '-12'))
for testtuple in testtuples:
result = PythonTimeBuilder.build_timezone(**testtuple[0])
self.assertEqual(result.utcoffset(None), testtuple[1])
self.assertEqual(result.tzname(None), testtuple[2])
def test_build_week_date(self):
weekdate = PythonTimeBuilder._build_week_date(2009, 1)
self.assertEqual(weekdate, datetime.date(year=2008, month=12, day=29))
weekdate = PythonTimeBuilder._build_week_date(2009, 53, isoday=7)
self.assertEqual(weekdate, datetime.date(year=2010, month=1, day=3))
def test_build_ordinal_date(self):
ordinaldate = PythonTimeBuilder._build_ordinal_date(1981, 95)
self.assertEqual(ordinaldate, datetime.date(year=1981, month=4, day=5))
def test_build_ordinal_date_bounds_checking(self):
with self.assertRaises(DayOutOfBoundsError):
PythonTimeBuilder._build_ordinal_date(1234, 0)
with self.assertRaises(DayOutOfBoundsError):
PythonTimeBuilder._build_ordinal_date(1234, 367)
def test_iso_year_start(self):
yearstart = PythonTimeBuilder._iso_year_start(2004)
self.assertEqual(yearstart, datetime.date(year=2003, month=12, day=29))
yearstart = PythonTimeBuilder._iso_year_start(2010)
self.assertEqual(yearstart, datetime.date(year=2010, month=1, day=4))
yearstart = PythonTimeBuilder._iso_year_start(2009)
self.assertEqual(yearstart, datetime.date(year=2008, month=12, day=29))
def test_date_generator(self):
startdate = datetime.date(year=2018, month=8, day=29)
timedelta = datetime.timedelta(days=1)
iterations = 10
generator = PythonTimeBuilder._date_generator(startdate,
timedelta,
iterations)
results = list(generator)
for dateindex in compat.range(0, 10):
self.assertEqual(results[dateindex],
datetime.date(year=2018, month=8, day=29)
+ dateindex * datetime.timedelta(days=1))
def test_date_generator_unbounded(self):
startdate = datetime.date(year=2018, month=8, day=29)
timedelta = datetime.timedelta(days=5)
generator = PythonTimeBuilder._date_generator_unbounded(startdate,
timedelta)
#Check the first 10 results
for dateindex in compat.range(0, 10):
self.assertEqual(next(generator),
datetime.date(year=2018, month=8, day=29)
+ dateindex * datetime.timedelta(days=5))
def test_split_to_microseconds(self):
result = PythonTimeBuilder._split_to_microseconds('1.1', int(1e6), 'dummy')
self.assertEqual(result, (1, 100000))
self.assertIsInstance(result[0], int)
self.assertIsInstance(result[1], int)
result = PythonTimeBuilder._split_to_microseconds('1.000001', int(1e6), 'dummy')
self.assertEqual(result, (1, 1))
self.assertIsInstance(result[0], int)
self.assertIsInstance(result[1], int)
result = PythonTimeBuilder._split_to_microseconds('1.0000001', int(1e6), 'dummy')
self.assertEqual(result, (1, 0))
self.assertIsInstance(result[0], int)
self.assertIsInstance(result[1], int)
def test_split_to_microseconds_exception(self):
with self.assertRaises(ISOFormatError) as e:
PythonTimeBuilder._split_to_microseconds('b.1', int(1e6), 'exception text')
self.assertEqual(str(e.exception), 'exception text')
with self.assertRaises(ISOFormatError) as e:
PythonTimeBuilder._split_to_microseconds('1.ad', int(1e6), 'exception text')
self.assertEqual(str(e.exception), 'exception text')
def test_distribute_microseconds(self):
self.assertEqual(PythonTimeBuilder._distribute_microseconds(1, (), ()), (1,))
self.assertEqual(PythonTimeBuilder._distribute_microseconds(11, (0,), (10,)), (1, 1))
self.assertEqual(PythonTimeBuilder._distribute_microseconds(211, (0, 0), (100, 10)), (2, 1, 1))
self.assertEqual(PythonTimeBuilder._distribute_microseconds(1, (), ()), (1,))
self.assertEqual(PythonTimeBuilder._distribute_microseconds(11, (5,), (10,)), (6, 1))
self.assertEqual(PythonTimeBuilder._distribute_microseconds(211, (10, 5), (100, 10)), (12, 6, 1))