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),