def __init__(self, node, root=None, parent=None, *args, **kwargs):
super().__init__(node, root, parent, *args, **kwargs)
self.i = kwargs.get("i", 0)
self.id = self.attr("id")
self.bitstreamSwitching = self.attr("bitstreamSwitching",
parser=MPDParsers.bool_str)
self.duration = self.attr("duration",
default=Duration(),
parser=MPDParsers.duration)
self.start = self.attr("start",
default=Duration(),
parser=MPDParsers.duration)
if self.start is None and self.i == 0 and self.root.type == "static":
self.start = 0
# TODO: Early Access Periods
self.baseURLs = self.children(BaseURL)
self.segmentBase = self.only_child(SegmentBase)
self.adaptationSets = self.children(AdaptationSet, minimum=1)
self.segmentList = self.only_child(SegmentList)
self.segmentTemplate = self.only_child(SegmentTemplate)
self.sssetIdentifier = self.only_child(AssetIdentifier)
self.eventStream = self.children(EventStream)
self.subset = self.children(Subset)
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))
class AtlasGranularities(object):
"""Helper class to create ISO 8601 durations to pass to the API
To add more possible granularities, add them here.
"""
MINUTE = duration_isoformat(Duration(minutes=1))
FIVE_MINUTE = duration_isoformat(Duration(minutes=5))
HOUR = duration_isoformat(Duration(hours=1))
DAY = duration_isoformat(Duration(days=1))
def test_associative(self):
'''
Adding 2 durations to a date is not associative.
'''
days1 = Duration(days=1)
months1 = Duration(months=1)
start = date(2000, 3, 30)
res1 = start + days1 + months1
res2 = start + months1 + days1
self.assertNotEqual(res1, res2)
def test_repr(self):
"""
Test __repr__ and __str__ for Duration objects.
"""
dur = Duration(10, 10, years=10, months=10)
self.assertEqual("10 years, 10 months, 10 days, 0:00:10", str(dur))
self.assertEqual(
"isodate.duration.Duration(10, 10, 0,"
" years=10, months=10)", repr(dur))
dur = Duration(months=0)
self.assertEqual("0:00:00", str(dur))
dur = Duration(months=1)
self.assertEqual("1 month, 0:00:00", str(dur))
def test_repr(self):
'''
Test __repr__ and __str__ for Duration objects.
'''
dur = Duration(10, 10, years=10, months=10)
self.assertEqual('10 years, 10 months, 10 days, 0:00:10', str(dur))
self.assertEqual(
'isodate.duration.Duration(10, 10, 0,'
' years=10, months=10)', repr(dur))
dur = Duration(months=0)
self.assertEqual('0:00:00', str(dur))
dur = Duration(months=1)
self.assertEqual('1 month, 0:00:00', str(dur))
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_hash(self):
"""
Test __hash__ for Duration objects.
"""
dur1 = Duration(10, 10, years=10, months=10)
dur2 = Duration(9, 9, years=9, months=9)
dur3 = Duration(10, 10, years=10, months=10)
self.assertNotEqual(hash(dur1), hash(dur2))
self.assertNotEqual(id(dur1), id(dur2))
self.assertEqual(hash(dur1), hash(dur3))
self.assertNotEqual(id(dur1), id(dur3))
durSet = set()
durSet.add(dur1)
durSet.add(dur2)
durSet.add(dur3)
self.assertEqual(len(durSet), 2)
def test_neg(self):
'''
Test __neg__ for Duration objects.
'''
self.assertEqual(-Duration(0), Duration(0))
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), timedelta(days=-365))
self.assertNotEqual(-timedelta(days=365), Duration(years=-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.availabilityEndTime = self.attr(u"availabilityEndTime",
parser=MPDParsers.datetime)
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)
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_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))
"""
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),
# 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))
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),
# 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 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 to_native(self, obj):
if obj:
d = Duration(milliseconds=obj)
return duration_isoformat(d)
else:
return None