%global _empty_manifest_terminate_build 0 Name: python-isoduration Version: 20.11.0 Release: 1 Summary: Operations with ISO 8601 durations License: ISC License (ISCL) URL: https://github.com/bolsote/isoduration Source0: https://mirrors.nju.edu.cn/pypi/web/packages/7c/1a/3c8edc664e06e6bd06cce40c6b22da5f1429aa4224d0c590f3be21c91ead/isoduration-20.11.0.tar.gz BuildArch: noarch Requires: python3-arrow %description # isoduration: Operations with ISO 8601 durations. [![PyPI Package](https://img.shields.io/pypi/v/isoduration?style=flat-square)](https://pypi.org/project/isoduration/) ## 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: ``` P3Y6M4DT12H30M5S ``` 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`](https://pypi.org/project/isodate/). What we are trying to achieve here is to address the shortcomings of `isodate` (as described in their own [_Limitations_](https://github.com/gweis/isodate/#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`](src/isoduration/types.py) type. Given a ISO duration string we can produce such a type by using the `parse_duration()` function: ```py >>> 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](https://docs.python.org/3/library/dataclasses.html), so their members can be accessed in a non-surprising way. Besides just parsing them, a number of additional operations are available: - Durations can be compared and negated: ```py >>> parse_duration("P3Y4D") == parse_duration("P3Y4DT0H") True >>> -parse_duration("P3Y4D") Duration(DateDuration(years=Decimal('-3'), months=Decimal('0'), days=Decimal('-4'), weeks=Decimal('0')), TimeDuration(hours=Decimal('0'), minutes=Decimal('0'), seconds=Decimal('0'))) ``` - Durations can be added to, or subtracted from, Python datetimes: ```py >>> from datetime import datetime >>> datetime(2020, 3, 15) + parse_duration("P2Y") datetime.datetime(2022, 3, 15, 0, 0) >>> datetime(2020, 3, 15) - parse_duration("P33Y1M4D") datetime.datetime(1987, 2, 11, 0, 0) ``` - Durations are hashable, so they can be used as dictionary keys or as part of sets. - Durations can be formatted back to a ISO 8601-compliant duration string: ```py >>> from isoduration import parse_duration, format_duration >>> format_duration(parse_duration("P11YT2H")) 'P11YT2H' >>> str(parse_duration("P11YT2H")) 'P11YT2H' ``` ## How to improve it. These steps, in this order, should land you in a development environment: ```sh 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](https://tox.readthedocs.io). The output of `tox -l` and a careful read of [tox.ini](tox.ini) should get you there. ## FAQs. ### 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.](https://stackoverflow.com/a/1732454) ### Why is parsing the inverse of formatting, but the converse is not true? Because this wonderful representation is not unique. ### Why do you support ``? Probably because the standard made me to. ### Why do you not support ``? 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? Yes. ## References. - [XML Schema Part 2: Datatypes, Appendix D](https://www.w3.org/TR/xmlschema-2/#isoformats): This excitingly named document contains more details about ISO 8601 than any human should be allowed to understand. - [`isodate`](https://pypi.org/project/isodate/): The original implementation of ISO durations in Python. Worth a look. But ours is cooler. %package -n python3-isoduration Summary: Operations with ISO 8601 durations Provides: python-isoduration BuildRequires: python3-devel BuildRequires: python3-setuptools BuildRequires: python3-pip %description -n python3-isoduration # isoduration: Operations with ISO 8601 durations. [![PyPI Package](https://img.shields.io/pypi/v/isoduration?style=flat-square)](https://pypi.org/project/isoduration/) ## 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: ``` P3Y6M4DT12H30M5S ``` 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`](https://pypi.org/project/isodate/). What we are trying to achieve here is to address the shortcomings of `isodate` (as described in their own [_Limitations_](https://github.com/gweis/isodate/#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`](src/isoduration/types.py) type. Given a ISO duration string we can produce such a type by using the `parse_duration()` function: ```py >>> 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](https://docs.python.org/3/library/dataclasses.html), so their members can be accessed in a non-surprising way. Besides just parsing them, a number of additional operations are available: - Durations can be compared and negated: ```py >>> parse_duration("P3Y4D") == parse_duration("P3Y4DT0H") True >>> -parse_duration("P3Y4D") Duration(DateDuration(years=Decimal('-3'), months=Decimal('0'), days=Decimal('-4'), weeks=Decimal('0')), TimeDuration(hours=Decimal('0'), minutes=Decimal('0'), seconds=Decimal('0'))) ``` - Durations can be added to, or subtracted from, Python datetimes: ```py >>> from datetime import datetime >>> datetime(2020, 3, 15) + parse_duration("P2Y") datetime.datetime(2022, 3, 15, 0, 0) >>> datetime(2020, 3, 15) - parse_duration("P33Y1M4D") datetime.datetime(1987, 2, 11, 0, 0) ``` - Durations are hashable, so they can be used as dictionary keys or as part of sets. - Durations can be formatted back to a ISO 8601-compliant duration string: ```py >>> from isoduration import parse_duration, format_duration >>> format_duration(parse_duration("P11YT2H")) 'P11YT2H' >>> str(parse_duration("P11YT2H")) 'P11YT2H' ``` ## How to improve it. These steps, in this order, should land you in a development environment: ```sh 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](https://tox.readthedocs.io). The output of `tox -l` and a careful read of [tox.ini](tox.ini) should get you there. ## FAQs. ### 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.](https://stackoverflow.com/a/1732454) ### Why is parsing the inverse of formatting, but the converse is not true? Because this wonderful representation is not unique. ### Why do you support ``? Probably because the standard made me to. ### Why do you not support ``? 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? Yes. ## References. - [XML Schema Part 2: Datatypes, Appendix D](https://www.w3.org/TR/xmlschema-2/#isoformats): This excitingly named document contains more details about ISO 8601 than any human should be allowed to understand. - [`isodate`](https://pypi.org/project/isodate/): The original implementation of ISO durations in Python. Worth a look. But ours is cooler. %package help Summary: Development documents and examples for isoduration Provides: python3-isoduration-doc %description help # isoduration: Operations with ISO 8601 durations. [![PyPI Package](https://img.shields.io/pypi/v/isoduration?style=flat-square)](https://pypi.org/project/isoduration/) ## 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: ``` P3Y6M4DT12H30M5S ``` 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`](https://pypi.org/project/isodate/). What we are trying to achieve here is to address the shortcomings of `isodate` (as described in their own [_Limitations_](https://github.com/gweis/isodate/#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`](src/isoduration/types.py) type. Given a ISO duration string we can produce such a type by using the `parse_duration()` function: ```py >>> 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](https://docs.python.org/3/library/dataclasses.html), so their members can be accessed in a non-surprising way. Besides just parsing them, a number of additional operations are available: - Durations can be compared and negated: ```py >>> parse_duration("P3Y4D") == parse_duration("P3Y4DT0H") True >>> -parse_duration("P3Y4D") Duration(DateDuration(years=Decimal('-3'), months=Decimal('0'), days=Decimal('-4'), weeks=Decimal('0')), TimeDuration(hours=Decimal('0'), minutes=Decimal('0'), seconds=Decimal('0'))) ``` - Durations can be added to, or subtracted from, Python datetimes: ```py >>> from datetime import datetime >>> datetime(2020, 3, 15) + parse_duration("P2Y") datetime.datetime(2022, 3, 15, 0, 0) >>> datetime(2020, 3, 15) - parse_duration("P33Y1M4D") datetime.datetime(1987, 2, 11, 0, 0) ``` - Durations are hashable, so they can be used as dictionary keys or as part of sets. - Durations can be formatted back to a ISO 8601-compliant duration string: ```py >>> from isoduration import parse_duration, format_duration >>> format_duration(parse_duration("P11YT2H")) 'P11YT2H' >>> str(parse_duration("P11YT2H")) 'P11YT2H' ``` ## How to improve it. These steps, in this order, should land you in a development environment: ```sh 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](https://tox.readthedocs.io). The output of `tox -l` and a careful read of [tox.ini](tox.ini) should get you there. ## FAQs. ### 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.](https://stackoverflow.com/a/1732454) ### Why is parsing the inverse of formatting, but the converse is not true? Because this wonderful representation is not unique. ### Why do you support ``? Probably because the standard made me to. ### Why do you not support ``? 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? Yes. ## References. - [XML Schema Part 2: Datatypes, Appendix D](https://www.w3.org/TR/xmlschema-2/#isoformats): This excitingly named document contains more details about ISO 8601 than any human should be allowed to understand. - [`isodate`](https://pypi.org/project/isodate/): The original implementation of ISO durations in Python. Worth a look. But ours is cooler. %prep %autosetup -n isoduration-20.11.0 %build %py3_build %install %py3_install install -d -m755 %{buildroot}/%{_pkgdocdir} if [ -d doc ]; then cp -arf doc %{buildroot}/%{_pkgdocdir}; fi if [ -d docs ]; then cp -arf docs %{buildroot}/%{_pkgdocdir}; fi if [ -d example ]; then cp -arf example %{buildroot}/%{_pkgdocdir}; fi if [ -d examples ]; then cp -arf examples %{buildroot}/%{_pkgdocdir}; fi pushd %{buildroot} if [ -d usr/lib ]; then find usr/lib -type f -printf "/%h/%f\n" >> filelist.lst fi if [ -d usr/lib64 ]; then find usr/lib64 -type f -printf "/%h/%f\n" >> filelist.lst fi if [ -d usr/bin ]; then find usr/bin -type f -printf "/%h/%f\n" >> filelist.lst fi if [ -d usr/sbin ]; then find usr/sbin -type f -printf "/%h/%f\n" >> filelist.lst fi touch doclist.lst if [ -d usr/share/man ]; then find usr/share/man -type f -printf "/%h/%f.gz\n" >> doclist.lst fi popd mv %{buildroot}/filelist.lst . mv %{buildroot}/doclist.lst . %files -n python3-isoduration -f filelist.lst %dir %{python3_sitelib}/* %files help -f doclist.lst %{_docdir}/* %changelog * Mon Apr 10 2023 Python_Bot - 20.11.0-1 - Package Spec generated