experimental/cuda-ubi9/: isoduration-20.11.0 metadata and description

Homepage Simple index

Operations with ISO 8601 durations

author Víctor Muñoz
author_email victorm@marshland.es
  • Programming Language :: Python :: 3
  • Operating System :: OS Independent
  • License :: OSI Approved :: ISC License (ISCL)
  • Development Status :: 4 - Beta
  • Intended Audience :: Developers
  • Topic :: Software Development :: Libraries :: Python Modules
description_content_type text/markdown
keywords datetime,date,time,duration,duration-parsing,duration-string,iso8601,iso8601-duration
  • Repository, https://github.com/bolsote/isoduration
  • Bug Reports, https://github.com/bolsote/isoduration/issues
  • Changelog, https://github.com/bolsote/isoduration/blob/master/CHANGELOG
  • arrow >=0.15.0
requires_python >=3.7
File Tox results History
11 KB
Python Wheel

isoduration: Operations with ISO 8601 durations.

PyPI Package

What is this.

ISO 8601 is most commonly known as a way to exchange datetimes in textual format. A lesser known aspect of the standard is the representation of durations. They have a shape similar to this:


This string represents a duration of 3 years, 6 months, 4 days, 12 hours, 30 minutes, and 5 seconds.

The state of the art of ISO 8601 duration handling in Python is more or less limited to what's offered by isodate. What we are trying to achieve here is to address the shortcomings of isodate (as described in their own Limitations section), and a few of our own annoyances with their interface, such as the lack of uniformity in their handling of types, and the use of regular expressions for parsing.

How to use it.

This package revolves around the Duration type.

Given a ISO duration string we can produce such a type by using the parse_duration() function:

>>> from isoduration import parse_duration
>>> duration = parse_duration("P3Y6M4DT12H30M5S")
>>> duration.date
DateDuration(years=Decimal('3'), months=Decimal('6'), days=Decimal('4'), weeks=Decimal('0'))
>>> duration.time
TimeDuration(hours=Decimal('12'), minutes=Decimal('30'), seconds=Decimal('5'))

The date and time portions of the parsed duration are just regular dataclasses, so their members can be accessed in a non-surprising way.

Besides just parsing them, a number of additional operations are available:

How to improve it.

These steps, in this order, should land you in a development environment:

git clone git@github.com:bolsote/isoduration.git
cd isoduration/
python -m venv ve
. ve/bin/activate
pip install -U pip
pip install -e .
pip install -r requirements/dev.txt

Adapt to your own likings and/or needs.

Testing is driven by tox. The output of tox -l and a careful read of tox.ini should get you there.


How come P1Y != P365D?

Some years have 366 days. If it's not always the same, then it's not the same.

Why do you create your own types, instead of somewhat shoehorning a timedelta?

timedelta cannot represent certain durations, such as those involving years or months. Since it cannot represent all possible durations without dangerous arithmetic, then it must not be the right type.

Why don't you use regular expressions to parse duration strings?

Regular expressions should only be used to parse regular languages.

Why is parsing the inverse of formatting, but the converse is not true?

Because this wonderful representation is not unique.

Why do you support <insert here a weird case>?

Probably because the standard made me to.

Why do you not support <insert here a weird case>?

Probably because the standard doesn't allow me to.

Why is it not possible to subtract a datetime from a duration?

I'm confused.

Why should I use this over some other thing?

You shouldn't do what people on the Internet tell you to do.

Why are ISO standards so strange?