def test_getattr_recursion(self):
"""
Test that when attempting to retrieve 'tdelta', which is used in
__getattr__, an AttributeError is raised. Some classes (like pickle)
do not call __init__, so when __getattr__ is called, it ends in an
infinite recursive loop.
"""
dur = Duration.__new__(Duration)
self.assertRaises(AttributeError, getattr, dur, 'tdelta')
def test_totimedelta(self):
'''
Test conversion form Duration to timedelta.
'''
dur = Duration(years=1, months=2, days=10)
self.assertEqual(dur.totimedelta(datetime(1998, 2, 25)),
timedelta(434))
# leap year has one day more in february
self.assertEqual(dur.totimedelta(datetime(2000, 2, 25)),
timedelta(435))
dur = Duration(months=2)
# march is longer than february, but april is shorter than
# march (cause only one day difference compared to 2)
self.assertEqual(dur.totimedelta(datetime(2000, 2, 25)), timedelta(60))
self.assertEqual(dur.totimedelta(datetime(2001, 2, 25)), timedelta(59))
self.assertEqual(dur.totimedelta(datetime(2001, 3, 25)), timedelta(61))
def test_format(self):
'''
Test various other strftime combinations.
'''
self.assertEqual(duration_isoformat(Duration(0)), 'P0D')
self.assertEqual(duration_isoformat(-Duration(0)), 'P0D')
self.assertEqual(duration_isoformat(Duration(seconds=10)), 'PT10S')
self.assertEqual(duration_isoformat(Duration(years=-1, months=-1)),
'-P1Y1M')
self.assertEqual(duration_isoformat(-Duration(years=1, months=1)),
'-P1Y1M')
self.assertEqual(duration_isoformat(-Duration(years=-1, months=-1)),
'P1Y1M')
self.assertEqual(duration_isoformat(-Duration(years=-1, months=-1)),
'P1Y1M')
dur = Duration(years=3, months=7, days=23, hours=5, minutes=25,
milliseconds=330)
self.assertEqual(duration_isoformat(dur), 'P3Y7M23DT5H25M0.33S')
self.assertEqual(duration_isoformat(-dur), '-P3Y7M23DT5H25M0.33S')
def from_duration(years=0,
months=0,
weeks=0,
days=0,
hours=0,
minutes=0,
seconds=0,
microseconds=0,
milliseconds=0):
return Duration(years=years,
months=months,
weeks=weeks,
days=days,
hours=hours,
minutes=minutes,
seconds=seconds,
milliseconds=milliseconds,
microseconds=microseconds)
def test_totimedelta(self):
'''
Test conversion form Duration to timedelta.
'''
dur = Duration(years=1, months=2, days=10)
self.assertEqual(dur.totimedelta(datetime(1998, 2, 25)), timedelta(434))
# leap year has one day more in february
self.assertEqual(dur.totimedelta(datetime(2000, 2, 25)), timedelta(435))
dur = Duration(months=2)
# march is longer than february, but april is shorter than march (cause only one day difference compared to 2)
self.assertEqual(dur.totimedelta(datetime(2000, 2, 25)), timedelta(60))
self.assertEqual(dur.totimedelta(datetime(2001, 2, 25)), timedelta(59))
self.assertEqual(dur.totimedelta(datetime(2001, 3, 25)), timedelta(61))
def test_typeerror(self):
'''
Test if TypError is raised with certain parameters.
'''
self.assertRaises(TypeError, parse_duration, date(2000, 1, 1))
self.assertRaises(TypeError, operator.sub, Duration(years=1),
date(2000, 1, 1))
self.assertRaises(TypeError, operator.sub, 'raise exc',
Duration(years=1))
self.assertRaises(TypeError, operator.add,
Duration(years=1, months=1, weeks=5),
'raise exception')
self.assertRaises(TypeError, operator.add, 'raise exception',
Duration(years=1, months=1, weeks=5))
self.assertRaises(TypeError, operator.mul,
Duration(years=1, months=1, weeks=5),
'raise exception')
self.assertRaises(TypeError, operator.mul, 'raise exception',
Duration(years=1, months=1, weeks=5))
self.assertRaises(TypeError, operator.mul,
Duration(years=1, months=1, weeks=5), 3.14)
self.assertRaises(TypeError, operator.mul, 3.14,
Duration(years=1, months=1, weeks=5))
def test_format(self):
"""
Test various other strftime combinations.
"""
self.assertEqual(duration_isoformat(Duration(0)), "P0D")
self.assertEqual(duration_isoformat(-Duration(0)), "P0D")
self.assertEqual(duration_isoformat(Duration(seconds=10)), "PT10S")
self.assertEqual(duration_isoformat(Duration(years=-1, months=-1)),
"-P1Y1M")
self.assertEqual(duration_isoformat(-Duration(years=1, months=1)),
"-P1Y1M")
self.assertEqual(duration_isoformat(-Duration(years=-1, months=-1)),
"P1Y1M")
self.assertEqual(duration_isoformat(-Duration(years=-1, months=-1)),
"P1Y1M")
dur = Duration(years=3,
months=7,
days=23,
hours=5,
minutes=25,
milliseconds=330)
self.assertEqual(duration_isoformat(dur), "P3Y7M23DT5H25M0.33S")
self.assertEqual(duration_isoformat(-dur), "-P3Y7M23DT5H25M0.33S")
def test_typeerror(self):
"""
Test if TypError is raised with certain parameters.
"""
self.assertRaises(TypeError, parse_duration, date(2000, 1, 1))
self.assertRaises(TypeError, operator.sub, Duration(years=1),
date(2000, 1, 1))
self.assertRaises(TypeError, operator.sub, "raise exc",
Duration(years=1))
self.assertRaises(
TypeError,
operator.add,
Duration(years=1, months=1, weeks=5),
"raise exception",
)
self.assertRaises(
TypeError,
operator.add,
"raise exception",
Duration(years=1, months=1, weeks=5),
)
self.assertRaises(
TypeError,
operator.mul,
Duration(years=1, months=1, weeks=5),
"raise exception",
)
self.assertRaises(
TypeError,
operator.mul,
"raise exception",
Duration(years=1, months=1, weeks=5),
)
self.assertRaises(TypeError, operator.mul,
Duration(years=1, months=1, weeks=5), 3.14)
self.assertRaises(TypeError, operator.mul, 3.14,
Duration(years=1, months=1, weeks=5))
def test_equal(self):
'''
Test __eq__ and __ne__ methods.
'''
self.assertEqual(Duration(years=1, months=1),
Duration(years=1, months=1))
self.assertEqual(Duration(years=1, months=1), Duration(months=13))
self.assertNotEqual(Duration(years=1, months=2),
Duration(years=1, months=1))
self.assertNotEqual(Duration(years=1, months=1), Duration(months=14))
self.assertNotEqual(Duration(years=1), timedelta(days=365))
self.assertFalse(Duration(years=1, months=1) !=
Duration(years=1, months=1))
self.assertFalse(Duration(years=1, months=1) != Duration(months=13))
self.assertTrue(Duration(years=1, months=2) !=
Duration(years=1, months=1))
self.assertTrue(Duration(years=1, months=1) != Duration(months=14))
self.assertTrue(Duration(years=1) != timedelta(days=365))
self.assertEqual(Duration(days=1), timedelta(days=1))
def __init__(self, node, root=None, parent=None, url=None, *args, **kwargs):
# top level has no parent
super(MPD, self).__init__(node, root=self, *args, **kwargs)
# parser attributes
self.url = url
self.timelines = defaultdict(lambda: -1)
self.timelines.update(kwargs.pop("timelines", {}))
self.id = self.attr(u"id")
self.profiles = self.attr(u"profiles", required=True)
self.type = self.attr(u"type", default=u"static", parser=MPDParsers.type)
self.minimumUpdatePeriod = self.attr(u"minimumUpdatePeriod", parser=MPDParsers.duration, default=Duration())
self.minBufferTime = self.attr(u"minBufferTime", parser=MPDParsers.duration, required=True)
self.timeShiftBufferDepth = self.attr(u"timeShiftBufferDepth", parser=MPDParsers.duration)
self.availabilityStartTime = self.attr(u"availabilityStartTime", parser=MPDParsers.datetime,
default=datetime.datetime.fromtimestamp(0, utc), # earliest date
required=self.type == "dynamic")
self.publishTime = self.attr(u"publishTime", parser=MPDParsers.datetime, required=self.type == "dynamic")
self.mediaPresentationDuration = self.attr(u"mediaPresentationDuration", parser=MPDParsers.duration)
self.suggestedPresentationDelay = self.attr(u"suggestedPresentationDelay", parser=MPDParsers.duration)
# parse children
location = self.children(Location)
self.location = location[0] if location else None
if self.location:
self.url = self.location.text
urlp = list(urlparse(self.url))
if urlp[2]:
urlp[2], _ = urlp[2].rsplit("/", 1)
self._base_url = urlunparse(urlp)
self.baseURLs = self.children(BaseURL)
self.periods = self.children(Period, minimum=1)
self.programInformation = self.children(ProgramInformation)
# CONTRACT, STRICT LIABILITY, OR TORT
##############################################################################
'''
Test cases for the isoduration module.
'''
import unittest
import operator
from datetime import timedelta, date, datetime
from isodate import Duration, parse_duration, ISO8601Error
from isodate import D_DEFAULT, D_WEEK, D_ALT_EXT, duration_isoformat
# the following list contains tuples of ISO duration strings and the expected
# result from the parse_duration method. A result of None means an ISO8601Error
# is expected.
PARSE_TEST_CASES = {'P18Y9M4DT11H9M8S': (Duration(4, 8, 0, 0, 9, 11, 0, 9, 18),
D_DEFAULT, None),
'P2W': (timedelta(weeks=2), D_WEEK, None),
'P3Y6M4DT12H30M5S': (Duration(4, 5, 0, 0, 30, 12, 0, 6, 3),
D_DEFAULT, None),
'P23DT23H': (timedelta(hours=23, days=23),
D_DEFAULT, None),
'P4Y': (Duration(years=4), D_DEFAULT, None),
'P1M': (Duration(months=1), D_DEFAULT, None),
'PT1M': (timedelta(minutes=1), D_DEFAULT, None),
'P0.5Y': (Duration(years=0.5), D_DEFAULT, None),
'PT36H': (timedelta(hours=36), D_DEFAULT, 'P1DT12H'),
'P1DT12H': (timedelta(days=1, hours=12), D_DEFAULT, None),
'+P11D': (timedelta(days=11), D_DEFAULT, 'P11D'),
'-P2W': (timedelta(weeks=-2), D_WEEK, None),
'-P2.2W': (timedelta(weeks=-2.2), D_DEFAULT,
class AtlasPeriods(object):
"""Helper class to create ISO 8601 durations to send to the Atlas period parameter.
To add more periods, add them here.
"""
MINUTES_15 = duration_isoformat(Duration(minutes=15))
HOURS_1 = duration_isoformat(Duration(hours=1))
HOURS_8 = duration_isoformat(Duration(hours=8))
HOURS_24 = duration_isoformat(Duration(hours=24))
HOURS_48 = duration_isoformat(Duration(hours=48))
WEEKS_1 = duration_isoformat(Duration(weeks=1))
WEEKS_4 = duration_isoformat(Duration(weeks=4))
MONTHS_1 = duration_isoformat(Duration(months=1))
MONTHS_2 = duration_isoformat(Duration(months=2))
YEARS_1 = duration_isoformat(Duration(years=1))
YEARS_2 = duration_isoformat(Duration(years=2))
##############################################################################
'''
Test cases for the isoduration module.
'''
import unittest
import operator
from datetime import timedelta, date, datetime
from isodate import Duration, parse_duration, ISO8601Error
from isodate import D_DEFAULT, D_WEEK, D_ALT_EXT, duration_isoformat
# the following list contains tuples of ISO duration strings and the expected
# result from the parse_duration method. A result of None means an ISO8601Error
# is expected.
PARSE_TEST_CASES = {
'P18Y9M4DT11H9M8S': (Duration(4, 8, 0, 0, 9, 11, 0, 9,
18), D_DEFAULT, None),
'P2W': (timedelta(weeks=2), D_WEEK, None),
'P3Y6M4DT12H30M5S': (Duration(4, 5, 0, 0, 30, 12, 0, 6,
3), D_DEFAULT, None),
'P23DT23H': (timedelta(hours=23, days=23), D_DEFAULT, None),
'P4Y': (Duration(years=4), D_DEFAULT, None),
'P1M': (Duration(months=1), D_DEFAULT, None),
'PT1M': (timedelta(minutes=1), D_DEFAULT, None),
'P0.5Y': (Duration(years=0.5), D_DEFAULT, None),
'PT36H': (timedelta(hours=36), D_DEFAULT, 'P1DT12H'),
'P1DT12H': (timedelta(days=1, hours=12), D_DEFAULT, None),
'+P11D': (timedelta(days=11), D_DEFAULT, 'P11D'),
'-P2W': (timedelta(weeks=-2), D_WEEK, None),
'-P2.2W': (timedelta(weeks=-2.2), D_DEFAULT, '-P15DT9H36M'),
'P1DT2H3M4S': (timedelta(days=1, hours=2, minutes=3,
seconds=4), D_DEFAULT, None),
def to_native(self, obj):
if obj:
d = Duration(milliseconds=obj)
return duration_isoformat(d)
else:
return None
# Create an Azure Service Bus namespace
sbnamespace = servicebus.Namespace('ns-messaging-samples',
sku='Standard',
name='ns-messaging-samples',
location='EastUs',
resource_group_name=resource_group.name)
# Create an associated queue within the above namespace
servicebus.Queue('simplequeue',
name='simplequeue',
namespace_name=sbnamespace.name,
dead_lettering_on_message_expiration=True,
resource_group_name=resource_group.name,
max_size_in_megabytes=1024,
default_message_ttl=duration_isoformat(Duration(days=5)))
# Create an associated topic within the above namespace
simpletopic = servicebus.Topic('simpletopic',
name='simpletopic',
resource_group_name=resource_group.name,
namespace_name=sbnamespace.name,
max_size_in_megabytes=1024,
status='Active')
servicebus.Subscription('all_messages',
name='all_messages',
resource_group_name=resource_group.name,
namespace_name=sbnamespace.name,
max_delivery_count=5,
dead_lettering_on_message_expiration=True,
def _parse_duration(datestring):
"""
Parses an ISO 8601 durations into datetime.timedelta or Duration objects.
If the ISO date string does not contain years or months, a timedelta
instance is returned, else a Duration instance is returned.
The following duration formats are supported:
-PnnW duration in weeks
-PnnYnnMnnDTnnHnnMnnS complete duration specification
-PYYYYMMDDThhmmss basic alternative complete date format
-PYYYY-MM-DDThh:mm:ss extended alternative complete date format
-PYYYYDDDThhmmss basic alternative ordinal date format
-PYYYY-DDDThh:mm:ss extended alternative ordinal date format
The '-' is optional.
Limitations: ISO standard defines some restrictions about where to use
fractional numbers and which component and format combinations are
allowed. This _base implementation ignores all those restrictions and
returns something when it is able to find all necessary components.
In detail:
it does not check, whether only the last component has fractions.
it allows weeks specified with all other combinations
The alternative format does not support durations with years, months or
days set to 0.
"""
if not isinstance(datestring, str):
raise TypeError("Expecting a string %r" % datestring)
match = isodate.isoduration.ISO8601_PERIOD_REGEX.match(datestring)
if not match:
# try alternative format:
if datestring.startswith("P"):
durdt = isodate.isoduration.parse_datetime(datestring[1:])
if durdt.year != 0 or durdt.month != 0:
# create Duration
ret = Duration(days=durdt.day,
seconds=durdt.second,
microseconds=durdt.microsecond,
minutes=durdt.minute,
hours=durdt.hour,
months=durdt.month,
years=durdt.year)
else: # FIXME: currently not possible in alternative format
# create timedelta
ret = timedelta(days=durdt.day,
seconds=durdt.second,
microseconds=durdt.microsecond,
minutes=durdt.minute,
hours=durdt.hour)
return ret
raise ISO8601Error("Unable to parse duration string %r" % datestring)
groups = match.groupdict()
for key, val in list(groups.items()):
if key not in ('separator', 'sign'):
if val is None:
groups[key] = "0n"
# print groups[key]
if key in ('years', 'months'):
groups[key] = Decimal(groups[key][:-1].replace(',', '.'))
else:
# these values are passed into a timedelta object,
# which works with floats.
groups[key] = float(groups[key][:-1].replace(',', '.'))
if groups["years"] == 0 and groups["months"] == 0:
ret = timedelta(days=groups["days"],
hours=groups["hours"],
minutes=groups["minutes"],
seconds=groups["seconds"],
weeks=groups["weeks"])
if groups["sign"] == '-':
ret = timedelta(0) - ret
else:
ret = Duration(years=groups["years"],
months=groups["months"],
days=groups["days"],
hours=groups["hours"],
minutes=groups["minutes"],
seconds=groups["seconds"],
weeks=groups["weeks"])
if groups["sign"] == '-':
ret = Duration(0) - ret
return ret
"""
Test cases for the isoduration module.
"""
import unittest
import operator
from datetime import timedelta, date, datetime
from isodate import Duration, parse_duration, ISO8601Error
from isodate import D_DEFAULT, D_WEEK, D_ALT_EXT, duration_isoformat
# the following list contains tuples of ISO duration strings and the expected
# result from the parse_duration method. A result of None means an ISO8601Error
# is expected.
PARSE_TEST_CASES = {
"P18Y9M4DT11H9M8S": (Duration(4, 8, 0, 0, 9, 11, 0, 9,
18), D_DEFAULT, None),
"P2W": (timedelta(weeks=2), D_WEEK, None),
"P3Y6M4DT12H30M5S": (Duration(4, 5, 0, 0, 30, 12, 0, 6,
3), D_DEFAULT, None),
"P23DT23H": (timedelta(hours=23, days=23), D_DEFAULT, None),
"P4Y": (Duration(years=4), D_DEFAULT, None),
"P1M": (Duration(months=1), D_DEFAULT, None),
"PT1M": (timedelta(minutes=1), D_DEFAULT, None),
"P0.5Y": (Duration(years=0.5), D_DEFAULT, None),
"PT36H": (timedelta(hours=36), D_DEFAULT, "P1DT12H"),
"P1DT12H": (timedelta(days=1, hours=12), D_DEFAULT, None),
"+P11D": (timedelta(days=11), D_DEFAULT, "P11D"),
"-P2W": (timedelta(weeks=-2), D_WEEK, None),
"-P2.2W": (timedelta(weeks=-2.2), D_DEFAULT, "-P15DT9H36M"),
"P1DT2H3M4S": (timedelta(days=1, hours=2, minutes=3,
seconds=4), D_DEFAULT, None),