diff options
| -rw-r--r-- | .gitignore | 1 | ||||
| -rw-r--r-- | python-dunamai.spec | 827 | ||||
| -rw-r--r-- | sources | 1 |
3 files changed, 829 insertions, 0 deletions
@@ -0,0 +1 @@ +/dunamai-1.16.0.tar.gz diff --git a/python-dunamai.spec b/python-dunamai.spec new file mode 100644 index 0000000..0ad9953 --- /dev/null +++ b/python-dunamai.spec @@ -0,0 +1,827 @@ +%global _empty_manifest_terminate_build 0 +Name: python-dunamai +Version: 1.16.0 +Release: 1 +Summary: Dynamic version generation +License: MIT +URL: https://github.com/mtkennerly/dunamai +Source0: https://mirrors.nju.edu.cn/pypi/web/packages/a3/85/4b6267f7fecad59f69b7f2e131c6896019912e3977fc4a0396c0cb562623/dunamai-1.16.0.tar.gz +BuildArch: noarch + +Requires: python3-packaging +Requires: python3-importlib-metadata + +%description + +# Dunamai +Dunamai is a Python 3.5+ library and command line tool for producing dynamic, +standards-compliant version strings, derived from tags in your version +control system. This facilitates uniquely identifying nightly or per-commit +builds in continuous integration and releasing new versions of your software +simply by creating a tag. + +Dunamai is also available as a [GitHub Action](https://github.com/marketplace/actions/run-dunamai). + +## Features +* Version control system support: + * [Git](https://git-scm.com) (2.7.0+ is recommended, but versions as old as 1.8.2.3 will work with some reduced functionality) + * [Mercurial](https://www.mercurial-scm.org) + * [Darcs](http://darcs.net) + * [Subversion](https://subversion.apache.org) + * [Bazaar](https://bazaar.canonical.com/en) + * [Fossil](https://www.fossil-scm.org/home/doc/trunk/www/index.wiki) + * [Pijul](https://pijul.org) +* Version styles: + * [PEP 440](https://www.python.org/dev/peps/pep-0440) + * [Semantic Versioning](https://semver.org) + * [Haskell Package Versioning Policy](https://pvp.haskell.org) + * Custom output formats +* Can be used for projects written in any programming language. + For Python, this means you do not need a setup.py. + +## Usage +### Installation +``` +pip install dunamai +``` + +### CLI +```console +# Suppose you are on commit g29045e8, 7 commits after the v0.2.0 tag. + +# Auto-detect the version control system and generate a version: +$ dunamai from any +0.2.0.post7.dev0+g29045e8 + +# Or use an explicit VCS and style: +$ dunamai from git --no-metadata --style semver +0.2.0-post.7 + +# Custom formats: +$ dunamai from any --format "v{base}+{distance}.{commit}" +v0.2.0+7.g29045e8 + +# If you'd prefer to frame the version in terms of progress toward the next +# release rather than distance from the latest one, you can bump it: +$ dunamai from any --bump +0.2.1.dev7+g29045e8 + +# Validation of custom formats: +$ dunamai from any --format "v{base}" --style pep440 +Version 'v0.2.0' does not conform to the PEP 440 style + +# Validate your own freeform versions: +$ dunamai check 0.01.0 --style semver +Version '0.01.0' does not conform to the Semantic Versioning style + +# More info: +$ dunamai --help +$ dunamai from --help +$ dunamai from git --help +``` + +### Library + +```python +from dunamai import Version, Style + +# Let's say you're on commit g644252b, which is tagged as v0.1.0. +version = Version.from_git() +assert version.serialize() == "0.1.0" + +# Let's say there was a v0.1.0rc5 tag 44 commits ago +# and you have some uncommitted changes. +version = Version.from_any_vcs() +assert version.serialize() == "0.1.0rc5.post44.dev0+g644252b" +assert version.serialize(metadata=False) == "0.1.0rc5.post44.dev0" +assert version.serialize(dirty=True) == "0.1.0rc5.post44.dev0+g644252b.dirty" +assert version.serialize(style=Style.SemVer) == "0.1.0-rc.5.post.44+g644252b" +``` + +The `serialize()` method gives you an opinionated, PEP 440-compliant default +that ensures that versions for untagged commits are compatible with Pip's +`--pre` flag. The individual parts of the version are also available for you +to use and inspect as you please: + +```python +assert version.base == "0.1.0" +assert version.stage == "rc" +assert version.revision == 5 +assert version.distance == 44 +assert version.commit == "g644252b" +assert version.dirty is True + +# Available if the latest tag includes metadata, like v0.1.0+linux: +assert version.tagged_metadata == "linux" +``` + +### Tips +By default, the "v" prefix on the tag is required, unless you specify +a custom tag pattern. You can either write a regular expression: + +```console +$ dunamai from any --pattern "(?P<base>\d+\.\d+\.\d+)" +``` + +```python +from dunamai import Version + +version = Version.from_any_vcs(pattern=r"(?P<base>\d+\.\d+\.\d+)") +``` + +...or use a named preset: + +```console +$ dunamai from any --pattern default-unprefixed +``` + +```python +from dunamai import Version, Pattern + +version = Version.from_any_vcs(pattern=Pattern.DefaultUnprefixed) +``` + +### VCS archives +Sometimes, you may only have access to an archive of a repository (e.g., a zip file) without the full history. +Dunamai can still detect a version in some of these cases: + +* For Git, you can configure `git archive` to produce a file with some metadata for Dunamai. + + Add a `.git_archival.json` file to the root of your repository with this content: + ``` + { + "hash-full": "$Format:%H$", + "hash-short": "$Format:%h$", + "timestamp": "$Format:%cI$", + "refs": "$Format:%D$", + "describe": "$Format:%(describe:tags=true,match=v[0-9]*)$" + } + ``` + + Add this line to your `.gitattributes` file. + If you don't already have this file, add it to the root of your repository: + ``` + .git_archival.json export-subst + ``` + +* For Mercurial, Dunamai will detect and use an `.hg_archival.txt` file created by `hg archive`. + It will also recognize `.hgtags` if present. + +### Custom formats +Here are the available substitutions for custom formats. If you have a tag like +`v9!0.1.2-beta.3+other`, then: + +* `{base}` = `0.1.2` +* `{stage}` = `beta` +* `{revision}` = `3` +* `{distance}` is the number of commits since the last +* `{commit}` is the commit hash (defaults to short form, unless you use `--full-commit`) +* `{dirty}` expands to either "dirty" or "clean" if you have uncommitted modified files +* `{tagged_metadata}` = `other` +* `{epoch}` = `9` +* `{branch}` = `feature/foo` +* `{branch_escaped}` = `featurefoo` +* `{timestamp}` is in the format `YYYYmmddHHMMSS` as UTC + +If you specify a substitution, its value will always be included in the output. +For conditional formatting, you can do something like this (Bash): + +```bash +distance=$(dunamai from any --format "{distance}") +if [ "$distance" = "0" ]; then + dunamai from any --format "v{base}" +else + dunamai from any --format "v{base}+{distance}.{dirty}" +fi +``` + +## Comparison to Versioneer +[Versioneer](https://github.com/warner/python-versioneer) is another great +library for dynamic versions, but there are some design decisions that +prompted the creation of Dunamai as an alternative: + +* Versioneer requires a setup.py file to exist, or else `versioneer install` + will fail, rendering it incompatible with non-setuptools-based projects + such as those using Poetry or Flit. Dunamai can be used regardless of the + project's build system. +* Versioneer has a CLI that generates Python code which needs to be committed + into your repository, whereas Dunamai is just a normal importable library + with an optional CLI to help statically include your version string. +* Versioneer produces the version as an opaque string, whereas Dunamai provides + a Version class with discrete parts that can then be inspected and serialized + separately. +* Versioneer provides customizability through a config file, whereas Dunamai + aims to offer customizability through its library API and CLI for both + scripting support and use in other libraries. + +## Integration +* Setting a `__version__` statically: + + ```console + $ echo "__version__ = '$(dunamai from any)'" > your_library/_version.py + ``` + ```python + # your_library/__init__.py + from your_library._version import __version__ + ``` + + Or dynamically (but Dunamai becomes a runtime dependency): + + ```python + # your_library/__init__.py + import dunamai as _dunamai + __version__ = _dunamai.get_version("your-library", third_choice=_dunamai.Version.from_any_vcs).serialize() + ``` + +* setup.py (no install-time dependency on Dunamai as long as you use wheels): + + ```python + from setuptools import setup + from dunamai import Version + + setup( + name="your-library", + version=Version.from_any_vcs().serialize(), + ) + ``` + + Or you could use a static inclusion approach as in the prior example. + +* [Poetry](https://poetry.eustace.io): + + ```console + $ poetry version $(dunamai from any) + ``` + + Or you can use the [poetry-dynamic-versioning](https://github.com/mtkennerly/poetry-dynamic-versioning) plugin. + +## Other notes +* When using Git, remember that lightweight tags do not store their creation time. + Therefore, if a commit has multiple lightweight tags, + we cannot reliably determine which one should be considered the newest. + The solution is to use annotated tags instead. +* When using Git, the initial commit must **not** be both tagged and empty + (i.e., created with `--allow-empty`). This is related to a reporting issue + in Git. For more info, [click here](https://github.com/mtkennerly/dunamai/issues/14). + + +%package -n python3-dunamai +Summary: Dynamic version generation +Provides: python-dunamai +BuildRequires: python3-devel +BuildRequires: python3-setuptools +BuildRequires: python3-pip +%description -n python3-dunamai + +# Dunamai +Dunamai is a Python 3.5+ library and command line tool for producing dynamic, +standards-compliant version strings, derived from tags in your version +control system. This facilitates uniquely identifying nightly or per-commit +builds in continuous integration and releasing new versions of your software +simply by creating a tag. + +Dunamai is also available as a [GitHub Action](https://github.com/marketplace/actions/run-dunamai). + +## Features +* Version control system support: + * [Git](https://git-scm.com) (2.7.0+ is recommended, but versions as old as 1.8.2.3 will work with some reduced functionality) + * [Mercurial](https://www.mercurial-scm.org) + * [Darcs](http://darcs.net) + * [Subversion](https://subversion.apache.org) + * [Bazaar](https://bazaar.canonical.com/en) + * [Fossil](https://www.fossil-scm.org/home/doc/trunk/www/index.wiki) + * [Pijul](https://pijul.org) +* Version styles: + * [PEP 440](https://www.python.org/dev/peps/pep-0440) + * [Semantic Versioning](https://semver.org) + * [Haskell Package Versioning Policy](https://pvp.haskell.org) + * Custom output formats +* Can be used for projects written in any programming language. + For Python, this means you do not need a setup.py. + +## Usage +### Installation +``` +pip install dunamai +``` + +### CLI +```console +# Suppose you are on commit g29045e8, 7 commits after the v0.2.0 tag. + +# Auto-detect the version control system and generate a version: +$ dunamai from any +0.2.0.post7.dev0+g29045e8 + +# Or use an explicit VCS and style: +$ dunamai from git --no-metadata --style semver +0.2.0-post.7 + +# Custom formats: +$ dunamai from any --format "v{base}+{distance}.{commit}" +v0.2.0+7.g29045e8 + +# If you'd prefer to frame the version in terms of progress toward the next +# release rather than distance from the latest one, you can bump it: +$ dunamai from any --bump +0.2.1.dev7+g29045e8 + +# Validation of custom formats: +$ dunamai from any --format "v{base}" --style pep440 +Version 'v0.2.0' does not conform to the PEP 440 style + +# Validate your own freeform versions: +$ dunamai check 0.01.0 --style semver +Version '0.01.0' does not conform to the Semantic Versioning style + +# More info: +$ dunamai --help +$ dunamai from --help +$ dunamai from git --help +``` + +### Library + +```python +from dunamai import Version, Style + +# Let's say you're on commit g644252b, which is tagged as v0.1.0. +version = Version.from_git() +assert version.serialize() == "0.1.0" + +# Let's say there was a v0.1.0rc5 tag 44 commits ago +# and you have some uncommitted changes. +version = Version.from_any_vcs() +assert version.serialize() == "0.1.0rc5.post44.dev0+g644252b" +assert version.serialize(metadata=False) == "0.1.0rc5.post44.dev0" +assert version.serialize(dirty=True) == "0.1.0rc5.post44.dev0+g644252b.dirty" +assert version.serialize(style=Style.SemVer) == "0.1.0-rc.5.post.44+g644252b" +``` + +The `serialize()` method gives you an opinionated, PEP 440-compliant default +that ensures that versions for untagged commits are compatible with Pip's +`--pre` flag. The individual parts of the version are also available for you +to use and inspect as you please: + +```python +assert version.base == "0.1.0" +assert version.stage == "rc" +assert version.revision == 5 +assert version.distance == 44 +assert version.commit == "g644252b" +assert version.dirty is True + +# Available if the latest tag includes metadata, like v0.1.0+linux: +assert version.tagged_metadata == "linux" +``` + +### Tips +By default, the "v" prefix on the tag is required, unless you specify +a custom tag pattern. You can either write a regular expression: + +```console +$ dunamai from any --pattern "(?P<base>\d+\.\d+\.\d+)" +``` + +```python +from dunamai import Version + +version = Version.from_any_vcs(pattern=r"(?P<base>\d+\.\d+\.\d+)") +``` + +...or use a named preset: + +```console +$ dunamai from any --pattern default-unprefixed +``` + +```python +from dunamai import Version, Pattern + +version = Version.from_any_vcs(pattern=Pattern.DefaultUnprefixed) +``` + +### VCS archives +Sometimes, you may only have access to an archive of a repository (e.g., a zip file) without the full history. +Dunamai can still detect a version in some of these cases: + +* For Git, you can configure `git archive` to produce a file with some metadata for Dunamai. + + Add a `.git_archival.json` file to the root of your repository with this content: + ``` + { + "hash-full": "$Format:%H$", + "hash-short": "$Format:%h$", + "timestamp": "$Format:%cI$", + "refs": "$Format:%D$", + "describe": "$Format:%(describe:tags=true,match=v[0-9]*)$" + } + ``` + + Add this line to your `.gitattributes` file. + If you don't already have this file, add it to the root of your repository: + ``` + .git_archival.json export-subst + ``` + +* For Mercurial, Dunamai will detect and use an `.hg_archival.txt` file created by `hg archive`. + It will also recognize `.hgtags` if present. + +### Custom formats +Here are the available substitutions for custom formats. If you have a tag like +`v9!0.1.2-beta.3+other`, then: + +* `{base}` = `0.1.2` +* `{stage}` = `beta` +* `{revision}` = `3` +* `{distance}` is the number of commits since the last +* `{commit}` is the commit hash (defaults to short form, unless you use `--full-commit`) +* `{dirty}` expands to either "dirty" or "clean" if you have uncommitted modified files +* `{tagged_metadata}` = `other` +* `{epoch}` = `9` +* `{branch}` = `feature/foo` +* `{branch_escaped}` = `featurefoo` +* `{timestamp}` is in the format `YYYYmmddHHMMSS` as UTC + +If you specify a substitution, its value will always be included in the output. +For conditional formatting, you can do something like this (Bash): + +```bash +distance=$(dunamai from any --format "{distance}") +if [ "$distance" = "0" ]; then + dunamai from any --format "v{base}" +else + dunamai from any --format "v{base}+{distance}.{dirty}" +fi +``` + +## Comparison to Versioneer +[Versioneer](https://github.com/warner/python-versioneer) is another great +library for dynamic versions, but there are some design decisions that +prompted the creation of Dunamai as an alternative: + +* Versioneer requires a setup.py file to exist, or else `versioneer install` + will fail, rendering it incompatible with non-setuptools-based projects + such as those using Poetry or Flit. Dunamai can be used regardless of the + project's build system. +* Versioneer has a CLI that generates Python code which needs to be committed + into your repository, whereas Dunamai is just a normal importable library + with an optional CLI to help statically include your version string. +* Versioneer produces the version as an opaque string, whereas Dunamai provides + a Version class with discrete parts that can then be inspected and serialized + separately. +* Versioneer provides customizability through a config file, whereas Dunamai + aims to offer customizability through its library API and CLI for both + scripting support and use in other libraries. + +## Integration +* Setting a `__version__` statically: + + ```console + $ echo "__version__ = '$(dunamai from any)'" > your_library/_version.py + ``` + ```python + # your_library/__init__.py + from your_library._version import __version__ + ``` + + Or dynamically (but Dunamai becomes a runtime dependency): + + ```python + # your_library/__init__.py + import dunamai as _dunamai + __version__ = _dunamai.get_version("your-library", third_choice=_dunamai.Version.from_any_vcs).serialize() + ``` + +* setup.py (no install-time dependency on Dunamai as long as you use wheels): + + ```python + from setuptools import setup + from dunamai import Version + + setup( + name="your-library", + version=Version.from_any_vcs().serialize(), + ) + ``` + + Or you could use a static inclusion approach as in the prior example. + +* [Poetry](https://poetry.eustace.io): + + ```console + $ poetry version $(dunamai from any) + ``` + + Or you can use the [poetry-dynamic-versioning](https://github.com/mtkennerly/poetry-dynamic-versioning) plugin. + +## Other notes +* When using Git, remember that lightweight tags do not store their creation time. + Therefore, if a commit has multiple lightweight tags, + we cannot reliably determine which one should be considered the newest. + The solution is to use annotated tags instead. +* When using Git, the initial commit must **not** be both tagged and empty + (i.e., created with `--allow-empty`). This is related to a reporting issue + in Git. For more info, [click here](https://github.com/mtkennerly/dunamai/issues/14). + + +%package help +Summary: Development documents and examples for dunamai +Provides: python3-dunamai-doc +%description help + +# Dunamai +Dunamai is a Python 3.5+ library and command line tool for producing dynamic, +standards-compliant version strings, derived from tags in your version +control system. This facilitates uniquely identifying nightly or per-commit +builds in continuous integration and releasing new versions of your software +simply by creating a tag. + +Dunamai is also available as a [GitHub Action](https://github.com/marketplace/actions/run-dunamai). + +## Features +* Version control system support: + * [Git](https://git-scm.com) (2.7.0+ is recommended, but versions as old as 1.8.2.3 will work with some reduced functionality) + * [Mercurial](https://www.mercurial-scm.org) + * [Darcs](http://darcs.net) + * [Subversion](https://subversion.apache.org) + * [Bazaar](https://bazaar.canonical.com/en) + * [Fossil](https://www.fossil-scm.org/home/doc/trunk/www/index.wiki) + * [Pijul](https://pijul.org) +* Version styles: + * [PEP 440](https://www.python.org/dev/peps/pep-0440) + * [Semantic Versioning](https://semver.org) + * [Haskell Package Versioning Policy](https://pvp.haskell.org) + * Custom output formats +* Can be used for projects written in any programming language. + For Python, this means you do not need a setup.py. + +## Usage +### Installation +``` +pip install dunamai +``` + +### CLI +```console +# Suppose you are on commit g29045e8, 7 commits after the v0.2.0 tag. + +# Auto-detect the version control system and generate a version: +$ dunamai from any +0.2.0.post7.dev0+g29045e8 + +# Or use an explicit VCS and style: +$ dunamai from git --no-metadata --style semver +0.2.0-post.7 + +# Custom formats: +$ dunamai from any --format "v{base}+{distance}.{commit}" +v0.2.0+7.g29045e8 + +# If you'd prefer to frame the version in terms of progress toward the next +# release rather than distance from the latest one, you can bump it: +$ dunamai from any --bump +0.2.1.dev7+g29045e8 + +# Validation of custom formats: +$ dunamai from any --format "v{base}" --style pep440 +Version 'v0.2.0' does not conform to the PEP 440 style + +# Validate your own freeform versions: +$ dunamai check 0.01.0 --style semver +Version '0.01.0' does not conform to the Semantic Versioning style + +# More info: +$ dunamai --help +$ dunamai from --help +$ dunamai from git --help +``` + +### Library + +```python +from dunamai import Version, Style + +# Let's say you're on commit g644252b, which is tagged as v0.1.0. +version = Version.from_git() +assert version.serialize() == "0.1.0" + +# Let's say there was a v0.1.0rc5 tag 44 commits ago +# and you have some uncommitted changes. +version = Version.from_any_vcs() +assert version.serialize() == "0.1.0rc5.post44.dev0+g644252b" +assert version.serialize(metadata=False) == "0.1.0rc5.post44.dev0" +assert version.serialize(dirty=True) == "0.1.0rc5.post44.dev0+g644252b.dirty" +assert version.serialize(style=Style.SemVer) == "0.1.0-rc.5.post.44+g644252b" +``` + +The `serialize()` method gives you an opinionated, PEP 440-compliant default +that ensures that versions for untagged commits are compatible with Pip's +`--pre` flag. The individual parts of the version are also available for you +to use and inspect as you please: + +```python +assert version.base == "0.1.0" +assert version.stage == "rc" +assert version.revision == 5 +assert version.distance == 44 +assert version.commit == "g644252b" +assert version.dirty is True + +# Available if the latest tag includes metadata, like v0.1.0+linux: +assert version.tagged_metadata == "linux" +``` + +### Tips +By default, the "v" prefix on the tag is required, unless you specify +a custom tag pattern. You can either write a regular expression: + +```console +$ dunamai from any --pattern "(?P<base>\d+\.\d+\.\d+)" +``` + +```python +from dunamai import Version + +version = Version.from_any_vcs(pattern=r"(?P<base>\d+\.\d+\.\d+)") +``` + +...or use a named preset: + +```console +$ dunamai from any --pattern default-unprefixed +``` + +```python +from dunamai import Version, Pattern + +version = Version.from_any_vcs(pattern=Pattern.DefaultUnprefixed) +``` + +### VCS archives +Sometimes, you may only have access to an archive of a repository (e.g., a zip file) without the full history. +Dunamai can still detect a version in some of these cases: + +* For Git, you can configure `git archive` to produce a file with some metadata for Dunamai. + + Add a `.git_archival.json` file to the root of your repository with this content: + ``` + { + "hash-full": "$Format:%H$", + "hash-short": "$Format:%h$", + "timestamp": "$Format:%cI$", + "refs": "$Format:%D$", + "describe": "$Format:%(describe:tags=true,match=v[0-9]*)$" + } + ``` + + Add this line to your `.gitattributes` file. + If you don't already have this file, add it to the root of your repository: + ``` + .git_archival.json export-subst + ``` + +* For Mercurial, Dunamai will detect and use an `.hg_archival.txt` file created by `hg archive`. + It will also recognize `.hgtags` if present. + +### Custom formats +Here are the available substitutions for custom formats. If you have a tag like +`v9!0.1.2-beta.3+other`, then: + +* `{base}` = `0.1.2` +* `{stage}` = `beta` +* `{revision}` = `3` +* `{distance}` is the number of commits since the last +* `{commit}` is the commit hash (defaults to short form, unless you use `--full-commit`) +* `{dirty}` expands to either "dirty" or "clean" if you have uncommitted modified files +* `{tagged_metadata}` = `other` +* `{epoch}` = `9` +* `{branch}` = `feature/foo` +* `{branch_escaped}` = `featurefoo` +* `{timestamp}` is in the format `YYYYmmddHHMMSS` as UTC + +If you specify a substitution, its value will always be included in the output. +For conditional formatting, you can do something like this (Bash): + +```bash +distance=$(dunamai from any --format "{distance}") +if [ "$distance" = "0" ]; then + dunamai from any --format "v{base}" +else + dunamai from any --format "v{base}+{distance}.{dirty}" +fi +``` + +## Comparison to Versioneer +[Versioneer](https://github.com/warner/python-versioneer) is another great +library for dynamic versions, but there are some design decisions that +prompted the creation of Dunamai as an alternative: + +* Versioneer requires a setup.py file to exist, or else `versioneer install` + will fail, rendering it incompatible with non-setuptools-based projects + such as those using Poetry or Flit. Dunamai can be used regardless of the + project's build system. +* Versioneer has a CLI that generates Python code which needs to be committed + into your repository, whereas Dunamai is just a normal importable library + with an optional CLI to help statically include your version string. +* Versioneer produces the version as an opaque string, whereas Dunamai provides + a Version class with discrete parts that can then be inspected and serialized + separately. +* Versioneer provides customizability through a config file, whereas Dunamai + aims to offer customizability through its library API and CLI for both + scripting support and use in other libraries. + +## Integration +* Setting a `__version__` statically: + + ```console + $ echo "__version__ = '$(dunamai from any)'" > your_library/_version.py + ``` + ```python + # your_library/__init__.py + from your_library._version import __version__ + ``` + + Or dynamically (but Dunamai becomes a runtime dependency): + + ```python + # your_library/__init__.py + import dunamai as _dunamai + __version__ = _dunamai.get_version("your-library", third_choice=_dunamai.Version.from_any_vcs).serialize() + ``` + +* setup.py (no install-time dependency on Dunamai as long as you use wheels): + + ```python + from setuptools import setup + from dunamai import Version + + setup( + name="your-library", + version=Version.from_any_vcs().serialize(), + ) + ``` + + Or you could use a static inclusion approach as in the prior example. + +* [Poetry](https://poetry.eustace.io): + + ```console + $ poetry version $(dunamai from any) + ``` + + Or you can use the [poetry-dynamic-versioning](https://github.com/mtkennerly/poetry-dynamic-versioning) plugin. + +## Other notes +* When using Git, remember that lightweight tags do not store their creation time. + Therefore, if a commit has multiple lightweight tags, + we cannot reliably determine which one should be considered the newest. + The solution is to use annotated tags instead. +* When using Git, the initial commit must **not** be both tagged and empty + (i.e., created with `--allow-empty`). This is related to a reporting issue + in Git. For more info, [click here](https://github.com/mtkennerly/dunamai/issues/14). + + +%prep +%autosetup -n dunamai-1.16.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-dunamai -f filelist.lst +%dir %{python3_sitelib}/* + +%files help -f doclist.lst +%{_docdir}/* + +%changelog +* Mon Apr 10 2023 Python_Bot <Python_Bot@openeuler.org> - 1.16.0-1 +- Package Spec generated @@ -0,0 +1 @@ +b9ba90b9c8cf8d58a24109603157f1ed dunamai-1.16.0.tar.gz |