From e0b66ccb00995c73e65057d9ba58f3901aa5699e5cab2d37e65783b6560ce8b5 Mon Sep 17 00:00:00 2001 From: Steve Kowalik Date: Fri, 12 Jan 2024 02:29:20 +0000 Subject: [PATCH] - Switch to autosetup and pyproject macros. - Stop using greedy globs in %files. - Add patches bump-versioneer.patch and fix-assertions.patch: * Support Python 3.12 changes. OBS-URL: https://build.opensuse.org/package/show/devel:languages:python/python-ed25519?expand=0&rev=7 --- bump-versioneer.patch | 2102 ++++++++++++++++++++++++++++++++++++++++ fix-assertions.patch | 323 ++++++ python-ed25519.changes | 8 + python-ed25519.spec | 19 +- 4 files changed, 2445 insertions(+), 7 deletions(-) create mode 100644 bump-versioneer.patch create mode 100644 fix-assertions.patch diff --git a/bump-versioneer.patch b/bump-versioneer.patch new file mode 100644 index 0000000..890e734 --- /dev/null +++ b/bump-versioneer.patch @@ -0,0 +1,2102 @@ +From 17316527e2517a45e464640c036c7c29da51fb36 Mon Sep 17 00:00:00 2001 +From: davfsa +Date: Sun, 21 Nov 2021 15:52:28 +0100 +Subject: [PATCH 1/3] Bump versioneer version to work with python 3.11 + + - Switch from Travis to GitHub Actions +--- + .github/workflows/ci.yml | 31 + + .gitignore | 31 +- + .travis.yml | 17 - + src/ed25519/_version.py | 396 ++++++++---- + versioneer.py | 1284 +++++++++++++++++++++++++------------- + 5 files changed, 1196 insertions(+), 563 deletions(-) + create mode 100644 .github/workflows/ci.yml + delete mode 100644 .travis.yml + +Index: ed25519-1.5/.github/workflows/ci.yml +=================================================================== +--- /dev/null ++++ ed25519-1.5/.github/workflows/ci.yml +@@ -0,0 +1,31 @@ ++name: CI ++ ++on: ++ push: ++ pull_request: ++ ++jobs: ++ test-install: ++ strategy: ++ fail-fast: false ++ matrix: ++ os: [ubuntu-latest, macos-latest, windows-latest] ++ python-version: [2.7, 3.4, 3.5, 3.6, 3.7, 3.8, 3.9, "3.10", 3.11-dev, pypy-2.7, pypy-3.6, pypy-3.7, pypy-3.8] ++ ++ runs-on: ${{ matrix.os }} ++ ++ steps: ++ - name: Checkout repo ++ uses: actions/checkout@v2.4.0 ++ ++ - name: Setup python ++ uses: actions/setup-python@v2.3.0 ++ with: ++ python-version: ${{ matrix.python-version }} ++ ++ - name: Test Installation ++ run: | ++ python setup.py build ++ python setup.py test ++ python setup.py test_kat ++ python setup.py speed +Index: ed25519-1.5/versioneer.py +=================================================================== +--- ed25519-1.5.orig/versioneer.py ++++ ed25519-1.5/versioneer.py +@@ -1,21 +1,18 @@ + +-# Version: 0.15 ++# Version: 0.21 ++ ++"""The Versioneer - like a rocketeer, but for versions. + +-""" + The Versioneer + ============== + + * like a rocketeer, but for versions! +-* https://github.com/warner/python-versioneer ++* https://github.com/python-versioneer/python-versioneer + * Brian Warner + * License: Public Domain +-* Compatible With: python2.6, 2.7, 3.2, 3.3, 3.4, and pypy +-* [![Latest Version] +-(https://pypip.in/version/versioneer/badge.svg?style=flat) +-](https://pypi.python.org/pypi/versioneer/) +-* [![Build Status] +-(https://travis-ci.org/warner/python-versioneer.png?branch=master) +-](https://travis-ci.org/warner/python-versioneer) ++* Compatible with: Python 3.6, 3.7, 3.8, 3.9 and pypy3 ++* [![Latest Version][pypi-image]][pypi-url] ++* [![Build Status][travis-image]][travis-url] + + This is a tool for managing a recorded version number in distutils-based + python projects. The goal is to remove the tedious and error-prone "update +@@ -26,9 +23,10 @@ system, and maybe making new tarballs. + + ## Quick Install + +-* `pip install versioneer` to somewhere to your $PATH +-* add a `[versioneer]` section to your setup.cfg (see below) ++* `pip install versioneer` to somewhere in your $PATH ++* add a `[versioneer]` section to your setup.cfg (see [Install](INSTALL.md)) + * run `versioneer install` in your source tree, commit the results ++* Verify version information with `python setup.py version` + + ## Version Identifiers + +@@ -60,7 +58,7 @@ version 1.3). Many VCS systems can repor + for example `git describe --tags --dirty --always` reports things like + "0.7-1-g574ab98-dirty" to indicate that the checkout is one revision past the + 0.7 tag, has a unique revision id of "574ab98", and is "dirty" (it has +-uncommitted changes. ++uncommitted changes). + + The version identifier is used for multiple purposes: + +@@ -87,125 +85,7 @@ the generated version data. + + ## Installation + +-First, decide on values for the following configuration variables: +- +-* `VCS`: the version control system you use. Currently accepts "git". +- +-* `style`: the style of version string to be produced. See "Styles" below for +- details. Defaults to "pep440", which looks like +- `TAG[+DISTANCE.gSHORTHASH[.dirty]]`. +- +-* `versionfile_source`: +- +- A project-relative pathname into which the generated version strings should +- be written. This is usually a `_version.py` next to your project's main +- `__init__.py` file, so it can be imported at runtime. If your project uses +- `src/myproject/__init__.py`, this should be `src/myproject/_version.py`. +- This file should be checked in to your VCS as usual: the copy created below +- by `setup.py setup_versioneer` will include code that parses expanded VCS +- keywords in generated tarballs. The 'build' and 'sdist' commands will +- replace it with a copy that has just the calculated version string. +- +- This must be set even if your project does not have any modules (and will +- therefore never import `_version.py`), since "setup.py sdist" -based trees +- still need somewhere to record the pre-calculated version strings. Anywhere +- in the source tree should do. If there is a `__init__.py` next to your +- `_version.py`, the `setup.py setup_versioneer` command (described below) +- will append some `__version__`-setting assignments, if they aren't already +- present. +- +-* `versionfile_build`: +- +- Like `versionfile_source`, but relative to the build directory instead of +- the source directory. These will differ when your setup.py uses +- 'package_dir='. If you have `package_dir={'myproject': 'src/myproject'}`, +- then you will probably have `versionfile_build='myproject/_version.py'` and +- `versionfile_source='src/myproject/_version.py'`. +- +- If this is set to None, then `setup.py build` will not attempt to rewrite +- any `_version.py` in the built tree. If your project does not have any +- libraries (e.g. if it only builds a script), then you should use +- `versionfile_build = None` and override `distutils.command.build_scripts` +- to explicitly insert a copy of `versioneer.get_version()` into your +- generated script. +- +-* `tag_prefix`: +- +- a string, like 'PROJECTNAME-', which appears at the start of all VCS tags. +- If your tags look like 'myproject-1.2.0', then you should use +- tag_prefix='myproject-'. If you use unprefixed tags like '1.2.0', this +- should be an empty string. +- +-* `parentdir_prefix`: +- +- a optional string, frequently the same as tag_prefix, which appears at the +- start of all unpacked tarball filenames. If your tarball unpacks into +- 'myproject-1.2.0', this should be 'myproject-'. To disable this feature, +- just omit the field from your `setup.cfg`. +- +-This tool provides one script, named `versioneer`. That script has one mode, +-"install", which writes a copy of `versioneer.py` into the current directory +-and runs `versioneer.py setup` to finish the installation. +- +-To versioneer-enable your project: +- +-* 1: Modify your `setup.cfg`, adding a section named `[versioneer]` and +- populating it with the configuration values you decided earlier (note that +- the option names are not case-sensitive): +- +- ```` +- [versioneer] +- VCS = git +- style = pep440 +- versionfile_source = src/myproject/_version.py +- versionfile_build = myproject/_version.py +- tag_prefix = "" +- parentdir_prefix = myproject- +- ```` +- +-* 2: Run `versioneer install`. This will do the following: +- +- * copy `versioneer.py` into the top of your source tree +- * create `_version.py` in the right place (`versionfile_source`) +- * modify your `__init__.py` (if one exists next to `_version.py`) to define +- `__version__` (by calling a function from `_version.py`) +- * modify your `MANIFEST.in` to include both `versioneer.py` and the +- generated `_version.py` in sdist tarballs +- +- `versioneer install` will complain about any problems it finds with your +- `setup.py` or `setup.cfg`. Run it multiple times until you have fixed all +- the problems. +- +-* 3: add a `import versioneer` to your setup.py, and add the following +- arguments to the setup() call: +- +- version=versioneer.get_version(), +- cmdclass=versioneer.get_cmdclass(), +- +-* 4: commit these changes to your VCS. To make sure you won't forget, +- `versioneer install` will mark everything it touched for addition using +- `git add`. Don't forget to add `setup.py` and `setup.cfg` too. +- +-## Post-Installation Usage +- +-Once established, all uses of your tree from a VCS checkout should get the +-current version string. All generated tarballs should include an embedded +-version string (so users who unpack them will not need a VCS tool installed). +- +-If you distribute your project through PyPI, then the release process should +-boil down to two steps: +- +-* 1: git tag 1.0 +-* 2: python setup.py register sdist upload +- +-If you distribute it through github (i.e. users use github to generate +-tarballs with `git archive`), the process is: +- +-* 1: git tag 1.0 +-* 2: git push; git push --tags +- +-Versioneer will report "0+untagged.NUMCOMMITS.gHASH" until your tree has at +-least one tag in its history. ++See [INSTALL.md](./INSTALL.md) for detailed installation instructions. + + ## Version-String Flavors + +@@ -226,6 +106,10 @@ information: + * `['full-revisionid']`: detailed revision identifier. For Git, this is the + full SHA1 commit id, e.g. "1076c978a8d3cfc70f408fe5974aa6c092c949ac". + ++* `['date']`: Date and time of the latest `HEAD` commit. For Git, it is the ++ commit date in ISO 8601 format. This will be None if the date is not ++ available. ++ + * `['dirty']`: a boolean, True if the tree has uncommitted changes. Note that + this is only accurate if run in a VCS checkout, otherwise it is likely to + be False or None +@@ -264,8 +148,8 @@ that this commit is two revisions ("+2") + software (exactly equal to a known tag), the identifier will only contain the + stripped tag, e.g. "0.11". + +-Other styles are available. See details.md in the Versioneer source tree for +-descriptions. ++Other styles are available. See [details.md](details.md) in the Versioneer ++source tree for descriptions. + + ## Debugging + +@@ -275,48 +159,84 @@ version`, which will run the version-loo + display the full contents of `get_versions()` (including the `error` string, + which may help identify what went wrong). + ++## Known Limitations ++ ++Some situations are known to cause problems for Versioneer. This details the ++most significant ones. More can be found on Github ++[issues page](https://github.com/python-versioneer/python-versioneer/issues). ++ ++### Subprojects ++ ++Versioneer has limited support for source trees in which `setup.py` is not in ++the root directory (e.g. `setup.py` and `.git/` are *not* siblings). The are ++two common reasons why `setup.py` might not be in the root: ++ ++* Source trees which contain multiple subprojects, such as ++ [Buildbot](https://github.com/buildbot/buildbot), which contains both ++ "master" and "slave" subprojects, each with their own `setup.py`, ++ `setup.cfg`, and `tox.ini`. Projects like these produce multiple PyPI ++ distributions (and upload multiple independently-installable tarballs). ++* Source trees whose main purpose is to contain a C library, but which also ++ provide bindings to Python (and perhaps other languages) in subdirectories. ++ ++Versioneer will look for `.git` in parent directories, and most operations ++should get the right version string. However `pip` and `setuptools` have bugs ++and implementation details which frequently cause `pip install .` from a ++subproject directory to fail to find a correct version string (so it usually ++defaults to `0+unknown`). ++ ++`pip install --editable .` should work correctly. `setup.py install` might ++work too. ++ ++Pip-8.1.1 is known to have this problem, but hopefully it will get fixed in ++some later version. ++ ++[Bug #38](https://github.com/python-versioneer/python-versioneer/issues/38) is tracking ++this issue. The discussion in ++[PR #61](https://github.com/python-versioneer/python-versioneer/pull/61) describes the ++issue from the Versioneer side in more detail. ++[pip PR#3176](https://github.com/pypa/pip/pull/3176) and ++[pip PR#3615](https://github.com/pypa/pip/pull/3615) contain work to improve ++pip to let Versioneer work correctly. ++ ++Versioneer-0.16 and earlier only looked for a `.git` directory next to the ++`setup.cfg`, so subprojects were completely unsupported with those releases. ++ ++### Editable installs with setuptools <= 18.5 ++ ++`setup.py develop` and `pip install --editable .` allow you to install a ++project into a virtualenv once, then continue editing the source code (and ++test) without re-installing after every change. ++ ++"Entry-point scripts" (`setup(entry_points={"console_scripts": ..})`) are a ++convenient way to specify executable scripts that should be installed along ++with the python package. ++ ++These both work as expected when using modern setuptools. When using ++setuptools-18.5 or earlier, however, certain operations will cause ++`pkg_resources.DistributionNotFound` errors when running the entrypoint ++script, which must be resolved by re-installing the package. This happens ++when the install happens with one version, then the egg_info data is ++regenerated while a different version is checked out. Many setup.py commands ++cause egg_info to be rebuilt (including `sdist`, `wheel`, and installing into ++a different virtualenv), so this can be surprising. ++ ++[Bug #83](https://github.com/python-versioneer/python-versioneer/issues/83) describes ++this one, but upgrading to a newer version of setuptools should probably ++resolve it. ++ ++ + ## Updating Versioneer + + To upgrade your project to a new release of Versioneer, do the following: + + * install the new Versioneer (`pip install -U versioneer` or equivalent) + * edit `setup.cfg`, if necessary, to include any new configuration settings +- indicated by the release notes ++ indicated by the release notes. See [UPGRADING](./UPGRADING.md) for details. + * re-run `versioneer install` in your source tree, to replace + `SRC/_version.py` + * commit any changed files + +-### Upgrading to 0.15 +- +-Starting with this version, Versioneer is configured with a `[versioneer]` +-section in your `setup.cfg` file. Earlier versions required the `setup.py` to +-set attributes on the `versioneer` module immediately after import. The new +-version will refuse to run (raising an exception during import) until you +-have provided the necessary `setup.cfg` section. +- +-In addition, the Versioneer package provides an executable named +-`versioneer`, and the installation process is driven by running `versioneer +-install`. In 0.14 and earlier, the executable was named +-`versioneer-installer` and was run without an argument. +- +-### Upgrading to 0.14 +- +-0.14 changes the format of the version string. 0.13 and earlier used +-hyphen-separated strings like "0.11-2-g1076c97-dirty". 0.14 and beyond use a +-plus-separated "local version" section strings, with dot-separated +-components, like "0.11+2.g1076c97". PEP440-strict tools did not like the old +-format, but should be ok with the new one. +- +-### Upgrading from 0.11 to 0.12 +- +-Nothing special. +- +-### Upgrading from 0.10 to 0.11 +- +-You must add a `versioneer.VCS = "git"` to your `setup.py` before re-running +-`setup.py setup_versioneer`. This will enable the use of additional +-version-control systems (SVN, etc) in the future. +- + ## Future Directions + + This tool is designed to make it easily extended to other version-control +@@ -330,35 +250,56 @@ installation by editing setup.py . Alter + direction and include code from all supported VCS systems, reducing the + number of intermediate scripts. + ++## Similar projects ++ ++* [setuptools_scm](https://github.com/pypa/setuptools_scm/) - a non-vendored build-time ++ dependency ++* [minver](https://github.com/jbweston/miniver) - a lightweight reimplementation of ++ versioneer ++* [versioningit](https://github.com/jwodder/versioningit) - a PEP 518-based setuptools ++ plugin + + ## License + +-To make Versioneer easier to embed, all its code is hereby released into the +-public domain. The `_version.py` that it creates is also in the public +-domain. ++To make Versioneer easier to embed, all its code is dedicated to the public ++domain. The `_version.py` that it creates is also in the public domain. ++Specifically, both are released under the Creative Commons "Public Domain ++Dedication" license (CC0-1.0), as described in ++https://creativecommons.org/publicdomain/zero/1.0/ . ++ ++[pypi-image]: https://img.shields.io/pypi/v/versioneer.svg ++[pypi-url]: https://pypi.python.org/pypi/versioneer/ ++[travis-image]: ++https://img.shields.io/travis/com/python-versioneer/python-versioneer.svg ++[travis-url]: https://travis-ci.com/github/python-versioneer/python-versioneer + + """ ++# pylint:disable=invalid-name,import-outside-toplevel,missing-function-docstring ++# pylint:disable=missing-class-docstring,too-many-branches,too-many-statements ++# pylint:disable=raise-missing-from,too-many-lines,too-many-locals,import-error ++# pylint:disable=too-few-public-methods,redefined-outer-name,consider-using-with ++# pylint:disable=attribute-defined-outside-init,too-many-arguments + +-from __future__ import print_function +-try: +- import configparser +-except ImportError: +- import ConfigParser as configparser ++import configparser + import errno + import json + import os + import re + import subprocess + import sys ++from typing import Callable, Dict + + + class VersioneerConfig: +- pass ++ """Container for Versioneer configuration parameters.""" + + + def get_root(): +- # we require that all commands are run from the project root, i.e. the +- # directory that contains setup.py, setup.cfg, and versioneer.py . ++ """Get the project root directory. ++ ++ We require that all commands are run from the project root, i.e. the ++ directory that contains setup.py, setup.cfg, and versioneer.py . ++ """ + root = os.path.realpath(os.path.abspath(os.getcwd())) + setup_py = os.path.join(root, "setup.py") + versioneer_py = os.path.join(root, "versioneer.py") +@@ -381,90 +322,99 @@ def get_root(): + # module-import table will cache the first one. So we can't use + # os.path.dirname(__file__), as that will find whichever + # versioneer.py was first imported, even in later projects. +- me = os.path.realpath(os.path.abspath(__file__)) +- if os.path.splitext(me)[0] != os.path.splitext(versioneer_py)[0]: ++ my_path = os.path.realpath(os.path.abspath(__file__)) ++ me_dir = os.path.normcase(os.path.splitext(my_path)[0]) ++ vsr_dir = os.path.normcase(os.path.splitext(versioneer_py)[0]) ++ if me_dir != vsr_dir: + print("Warning: build in %s is using versioneer.py from %s" +- % (os.path.dirname(me), versioneer_py)) ++ % (os.path.dirname(my_path), versioneer_py)) + except NameError: + pass + return root + + + def get_config_from_root(root): +- # This might raise EnvironmentError (if setup.cfg is missing), or ++ """Read the project setup.cfg file to determine Versioneer config.""" ++ # This might raise OSError (if setup.cfg is missing), or + # configparser.NoSectionError (if it lacks a [versioneer] section), or + # configparser.NoOptionError (if it lacks "VCS="). See the docstring at + # the top of versioneer.py for instructions on writing your setup.cfg . + setup_cfg = os.path.join(root, "setup.cfg") +- parser = configparser.SafeConfigParser() +- with open(setup_cfg, "r") as f: +- parser.readfp(f) ++ parser = configparser.ConfigParser() ++ with open(setup_cfg, "r") as cfg_file: ++ parser.read_file(cfg_file) + VCS = parser.get("versioneer", "VCS") # mandatory + +- def get(parser, name): +- if parser.has_option("versioneer", name): +- return parser.get("versioneer", name) +- return None ++ # Dict-like interface for non-mandatory entries ++ section = parser["versioneer"] ++ + cfg = VersioneerConfig() + cfg.VCS = VCS +- cfg.style = get(parser, "style") or "" +- cfg.versionfile_source = get(parser, "versionfile_source") +- cfg.versionfile_build = get(parser, "versionfile_build") +- cfg.tag_prefix = get(parser, "tag_prefix") +- cfg.parentdir_prefix = get(parser, "parentdir_prefix") +- cfg.verbose = get(parser, "verbose") ++ cfg.style = section.get("style", "") ++ cfg.versionfile_source = section.get("versionfile_source") ++ cfg.versionfile_build = section.get("versionfile_build") ++ cfg.tag_prefix = section.get("tag_prefix") ++ if cfg.tag_prefix in ("''", '""'): ++ cfg.tag_prefix = "" ++ cfg.parentdir_prefix = section.get("parentdir_prefix") ++ cfg.verbose = section.get("verbose") + return cfg + + + class NotThisMethod(Exception): +- pass ++ """Exception raised if a method is not valid for the current scenario.""" ++ + + # these dictionaries contain VCS-specific tools +-LONG_VERSION_PY = {} +-HANDLERS = {} ++LONG_VERSION_PY: Dict[str, str] = {} ++HANDLERS: Dict[str, Dict[str, Callable]] = {} + + + def register_vcs_handler(vcs, method): # decorator ++ """Create decorator to mark a method as the handler of a VCS.""" + def decorate(f): +- if vcs not in HANDLERS: +- HANDLERS[vcs] = {} +- HANDLERS[vcs][method] = f ++ """Store f in HANDLERS[vcs][method].""" ++ HANDLERS.setdefault(vcs, {})[method] = f + return f + return decorate + + +-def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False): ++def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False, ++ env=None): ++ """Call the given command(s).""" + assert isinstance(commands, list) +- p = None +- for c in commands: ++ process = None ++ for command in commands: + try: +- dispcmd = str([c] + args) ++ dispcmd = str([command] + args) + # remember shell=False, so use git.cmd on windows, not just git +- p = subprocess.Popen([c] + args, cwd=cwd, stdout=subprocess.PIPE, +- stderr=(subprocess.PIPE if hide_stderr +- else None)) ++ process = subprocess.Popen([command] + args, cwd=cwd, env=env, ++ stdout=subprocess.PIPE, ++ stderr=(subprocess.PIPE if hide_stderr ++ else None)) + break +- except EnvironmentError: ++ except OSError: + e = sys.exc_info()[1] + if e.errno == errno.ENOENT: + continue + if verbose: + print("unable to run %s" % dispcmd) + print(e) +- return None ++ return None, None + else: + if verbose: + print("unable to find command, tried %s" % (commands,)) +- return None +- stdout = p.communicate()[0].strip() +- if sys.version_info[0] >= 3: +- stdout = stdout.decode() +- if p.returncode != 0: ++ return None, None ++ stdout = process.communicate()[0].strip().decode() ++ if process.returncode != 0: + if verbose: + print("unable to run %s (error)" % dispcmd) +- return None +- return stdout +-LONG_VERSION_PY['git'] = ''' ++ print("stdout was %s" % stdout) ++ return None, process.returncode ++ return stdout, process.returncode ++ ++ ++LONG_VERSION_PY['git'] = r''' + # This file helps to compute a version number in source trees obtained from + # git-archive tarball (such as those provided by githubs download-from-tag + # feature). Distribution tarballs (built by setup.py sdist) and build +@@ -472,31 +422,37 @@ LONG_VERSION_PY['git'] = ''' + # that just contains the computed version number. + + # This file is released into the public domain. Generated by +-# versioneer-0.15 (https://github.com/warner/python-versioneer) ++# versioneer-0.21 (https://github.com/python-versioneer/python-versioneer) ++ ++"""Git implementation of _version.py.""" + + import errno + import os + import re + import subprocess + import sys ++from typing import Callable, Dict + + + def get_keywords(): ++ """Get the keywords needed to look up the version information.""" + # these strings will be replaced by git during git-archive. + # setup.py/versioneer.py will grep for the variable names, so they must + # each be defined on a line of their own. _version.py will just call + # get_keywords(). + git_refnames = "%(DOLLAR)sFormat:%%d%(DOLLAR)s" + git_full = "%(DOLLAR)sFormat:%%H%(DOLLAR)s" +- keywords = {"refnames": git_refnames, "full": git_full} ++ git_date = "%(DOLLAR)sFormat:%%ci%(DOLLAR)s" ++ keywords = {"refnames": git_refnames, "full": git_full, "date": git_date} + return keywords + + + class VersioneerConfig: +- pass ++ """Container for Versioneer configuration parameters.""" + + + def get_config(): ++ """Create, populate and return the VersioneerConfig() object.""" + # these strings are filled in when 'setup.py versioneer' creates + # _version.py + cfg = VersioneerConfig() +@@ -510,15 +466,17 @@ def get_config(): + + + class NotThisMethod(Exception): +- pass ++ """Exception raised if a method is not valid for the current scenario.""" + + +-LONG_VERSION_PY = {} +-HANDLERS = {} ++LONG_VERSION_PY: Dict[str, str] = {} ++HANDLERS: Dict[str, Dict[str, Callable]] = {} + + + def register_vcs_handler(vcs, method): # decorator ++ """Create decorator to mark a method as the handler of a VCS.""" + def decorate(f): ++ """Store f in HANDLERS[vcs][method].""" + if vcs not in HANDLERS: + HANDLERS[vcs] = {} + HANDLERS[vcs][method] = f +@@ -526,91 +484,121 @@ def register_vcs_handler(vcs, method): + return decorate + + +-def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False): ++def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False, ++ env=None): ++ """Call the given command(s).""" + assert isinstance(commands, list) +- p = None +- for c in commands: ++ process = None ++ for command in commands: + try: +- dispcmd = str([c] + args) ++ dispcmd = str([command] + args) + # remember shell=False, so use git.cmd on windows, not just git +- p = subprocess.Popen([c] + args, cwd=cwd, stdout=subprocess.PIPE, +- stderr=(subprocess.PIPE if hide_stderr +- else None)) ++ process = subprocess.Popen([command] + args, cwd=cwd, env=env, ++ stdout=subprocess.PIPE, ++ stderr=(subprocess.PIPE if hide_stderr ++ else None)) + break +- except EnvironmentError: ++ except OSError: + e = sys.exc_info()[1] + if e.errno == errno.ENOENT: + continue + if verbose: + print("unable to run %%s" %% dispcmd) + print(e) +- return None ++ return None, None + else: + if verbose: + print("unable to find command, tried %%s" %% (commands,)) +- return None +- stdout = p.communicate()[0].strip() +- if sys.version_info[0] >= 3: +- stdout = stdout.decode() +- if p.returncode != 0: ++ return None, None ++ stdout = process.communicate()[0].strip().decode() ++ if process.returncode != 0: + if verbose: + print("unable to run %%s (error)" %% dispcmd) +- return None +- return stdout ++ print("stdout was %%s" %% stdout) ++ return None, process.returncode ++ return stdout, process.returncode + + + def versions_from_parentdir(parentdir_prefix, root, verbose): +- # Source tarballs conventionally unpack into a directory that includes +- # both the project name and a version string. +- dirname = os.path.basename(root) +- if not dirname.startswith(parentdir_prefix): +- if verbose: +- print("guessing rootdir is '%%s', but '%%s' doesn't start with " +- "prefix '%%s'" %% (root, dirname, parentdir_prefix)) +- raise NotThisMethod("rootdir doesn't start with parentdir_prefix") +- return {"version": dirname[len(parentdir_prefix):], +- "full-revisionid": None, +- "dirty": False, "error": None} ++ """Try to determine the version from the parent directory name. ++ ++ Source tarballs conventionally unpack into a directory that includes both ++ the project name and a version string. We will also support searching up ++ two directory levels for an appropriately named parent directory ++ """ ++ rootdirs = [] ++ ++ for _ in range(3): ++ dirname = os.path.basename(root) ++ if dirname.startswith(parentdir_prefix): ++ return {"version": dirname[len(parentdir_prefix):], ++ "full-revisionid": None, ++ "dirty": False, "error": None, "date": None} ++ rootdirs.append(root) ++ root = os.path.dirname(root) # up a level ++ ++ if verbose: ++ print("Tried directories %%s but none started with prefix %%s" %% ++ (str(rootdirs), parentdir_prefix)) ++ raise NotThisMethod("rootdir doesn't start with parentdir_prefix") + + + @register_vcs_handler("git", "get_keywords") + def git_get_keywords(versionfile_abs): ++ """Extract version information from the given file.""" + # the code embedded in _version.py can just fetch the value of these + # keywords. When used from setup.py, we don't want to import _version.py, + # so we do it with a regexp instead. This function is not used from + # _version.py. + keywords = {} + try: +- f = open(versionfile_abs, "r") +- for line in f.readlines(): +- if line.strip().startswith("git_refnames ="): +- mo = re.search(r'=\s*"(.*)"', line) +- if mo: +- keywords["refnames"] = mo.group(1) +- if line.strip().startswith("git_full ="): +- mo = re.search(r'=\s*"(.*)"', line) +- if mo: +- keywords["full"] = mo.group(1) +- f.close() +- except EnvironmentError: ++ with open(versionfile_abs, "r") as fobj: ++ for line in fobj: ++ if line.strip().startswith("git_refnames ="): ++ mo = re.search(r'=\s*"(.*)"', line) ++ if mo: ++ keywords["refnames"] = mo.group(1) ++ if line.strip().startswith("git_full ="): ++ mo = re.search(r'=\s*"(.*)"', line) ++ if mo: ++ keywords["full"] = mo.group(1) ++ if line.strip().startswith("git_date ="): ++ mo = re.search(r'=\s*"(.*)"', line) ++ if mo: ++ keywords["date"] = mo.group(1) ++ except OSError: + pass + return keywords + + + @register_vcs_handler("git", "keywords") + def git_versions_from_keywords(keywords, tag_prefix, verbose): +- if not keywords: +- raise NotThisMethod("no keywords at all, weird") ++ """Get version information from git keywords.""" ++ if "refnames" not in keywords: ++ raise NotThisMethod("Short version file found") ++ date = keywords.get("date") ++ if date is not None: ++ # Use only the last line. Previous lines may contain GPG signature ++ # information. ++ date = date.splitlines()[-1] ++ ++ # git-2.2.0 added "%%cI", which expands to an ISO-8601 -compliant ++ # datestamp. However we prefer "%%ci" (which expands to an "ISO-8601 ++ # -like" string, which we must then edit to make compliant), because ++ # it's been around since git-1.5.3, and it's too difficult to ++ # discover which version we're using, or to work around using an ++ # older one. ++ date = date.strip().replace(" ", "T", 1).replace(" ", "", 1) + refnames = keywords["refnames"].strip() + if refnames.startswith("$Format"): + if verbose: + print("keywords are unexpanded, not using") + raise NotThisMethod("unexpanded keywords, not a git-archive tarball") +- refs = set([r.strip() for r in refnames.strip("()").split(",")]) ++ refs = {r.strip() for r in refnames.strip("()").split(",")} + # starting in git-1.8.3, tags are listed as "tag: foo-1.0" instead of + # just "foo-1.0". If we see a "tag: " prefix, prefer those. + TAG = "tag: " +- tags = set([r[len(TAG):] for r in refs if r.startswith(TAG)]) ++ tags = {r[len(TAG):] for r in refs if r.startswith(TAG)} + if not tags: + # Either we're using git < 1.8.3, or there really are no tags. We use + # a heuristic: assume all version tags have a digit. The old git %%d +@@ -619,54 +607,67 @@ def git_versions_from_keywords(keywords, + # between branches and tags. By ignoring refnames without digits, we + # filter out many common branch names like "release" and + # "stabilization", as well as "HEAD" and "master". +- tags = set([r for r in refs if re.search(r'\d', r)]) ++ tags = {r for r in refs if re.search(r'\d', r)} + if verbose: +- print("discarding '%%s', no digits" %% ",".join(refs-tags)) ++ print("discarding '%%s', no digits" %% ",".join(refs - tags)) + if verbose: + print("likely tags: %%s" %% ",".join(sorted(tags))) + for ref in sorted(tags): + # sorting will prefer e.g. "2.0" over "2.0rc1" + if ref.startswith(tag_prefix): + r = ref[len(tag_prefix):] ++ # Filter out refs that exactly match prefix or that don't start ++ # with a number once the prefix is stripped (mostly a concern ++ # when prefix is '') ++ if not re.match(r'\d', r): ++ continue + if verbose: + print("picking %%s" %% r) + return {"version": r, + "full-revisionid": keywords["full"].strip(), +- "dirty": False, "error": None +- } ++ "dirty": False, "error": None, ++ "date": date} + # no suitable tags, so version is "0+unknown", but full hex is still there + if verbose: + print("no suitable tags, using unknown + full revision id") + return {"version": "0+unknown", + "full-revisionid": keywords["full"].strip(), +- "dirty": False, "error": "no suitable tags"} ++ "dirty": False, "error": "no suitable tags", "date": None} + + + @register_vcs_handler("git", "pieces_from_vcs") +-def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command): +- # this runs 'git' from the root of the source tree. This only gets called +- # if the git-archive 'subst' keywords were *not* expanded, and +- # _version.py hasn't already been rewritten with a short version string, +- # meaning we're inside a checked out source tree. +- +- if not os.path.exists(os.path.join(root, ".git")): +- if verbose: +- print("no .git in %%s" %% root) +- raise NotThisMethod("no .git directory") ++def git_pieces_from_vcs(tag_prefix, root, verbose, runner=run_command): ++ """Get version from 'git describe' in the root of the source tree. + ++ This only gets called if the git-archive 'subst' keywords were *not* ++ expanded, and _version.py hasn't already been rewritten with a short ++ version string, meaning we're inside a checked out source tree. ++ """ + GITS = ["git"] ++ TAG_PREFIX_REGEX = "*" + if sys.platform == "win32": + GITS = ["git.cmd", "git.exe"] +- # if there is a tag, this yields TAG-NUM-gHEX[-dirty] +- # if there are no tags, this yields HEX[-dirty] (no NUM) +- describe_out = run_command(GITS, ["describe", "--tags", "--dirty", +- "--always", "--long"], +- cwd=root) ++ TAG_PREFIX_REGEX = r"\*" ++ ++ _, rc = runner(GITS, ["rev-parse", "--git-dir"], cwd=root, ++ hide_stderr=True) ++ if rc != 0: ++ if verbose: ++ print("Directory %%s not under git control" %% root) ++ raise NotThisMethod("'git rev-parse --git-dir' returned error") ++ ++ # if there is a tag matching tag_prefix, this yields TAG-NUM-gHEX[-dirty] ++ # if there isn't one, this yields HEX[-dirty] (no NUM) ++ describe_out, rc = runner(GITS, ["describe", "--tags", "--dirty", ++ "--always", "--long", ++ "--match", ++ "%%s%%s" %% (tag_prefix, TAG_PREFIX_REGEX)], ++ cwd=root) + # --long was added in git-1.5.5 + if describe_out is None: + raise NotThisMethod("'git describe' failed") + describe_out = describe_out.strip() +- full_out = run_command(GITS, ["rev-parse", "HEAD"], cwd=root) ++ full_out, rc = runner(GITS, ["rev-parse", "HEAD"], cwd=root) + if full_out is None: + raise NotThisMethod("'git rev-parse' failed") + full_out = full_out.strip() +@@ -676,6 +677,39 @@ def git_pieces_from_vcs(tag_prefix, root + pieces["short"] = full_out[:7] # maybe improved later + pieces["error"] = None + ++ branch_name, rc = runner(GITS, ["rev-parse", "--abbrev-ref", "HEAD"], ++ cwd=root) ++ # --abbrev-ref was added in git-1.6.3 ++ if rc != 0 or branch_name is None: ++ raise NotThisMethod("'git rev-parse --abbrev-ref' returned error") ++ branch_name = branch_name.strip() ++ ++ if branch_name == "HEAD": ++ # If we aren't exactly on a branch, pick a branch which represents ++ # the current commit. If all else fails, we are on a branchless ++ # commit. ++ branches, rc = runner(GITS, ["branch", "--contains"], cwd=root) ++ # --contains was added in git-1.5.4 ++ if rc != 0 or branches is None: ++ raise NotThisMethod("'git branch --contains' returned error") ++ branches = branches.split("\n") ++ ++ # Remove the first line if we're running detached ++ if "(" in branches[0]: ++ branches.pop(0) ++ ++ # Strip off the leading "* " from the list of branches. ++ branches = [branch[2:] for branch in branches] ++ if "master" in branches: ++ branch_name = "master" ++ elif not branches: ++ branch_name = None ++ else: ++ # Pick the first branch that is returned. Good or bad. ++ branch_name = branches[0] ++ ++ pieces["branch"] = branch_name ++ + # parse describe_out. It will be like TAG-NUM-gHEX[-dirty] or HEX[-dirty] + # TAG might have hyphens. + git_describe = describe_out +@@ -692,7 +726,7 @@ def git_pieces_from_vcs(tag_prefix, root + # TAG-NUM-gHEX + mo = re.search(r'^(.+)-(\d+)-g([0-9a-f]+)$', git_describe) + if not mo: +- # unparseable. Maybe git-describe is misbehaving? ++ # unparsable. Maybe git-describe is misbehaving? + pieces["error"] = ("unable to parse git-describe output: '%%s'" + %% describe_out) + return pieces +@@ -717,27 +751,35 @@ def git_pieces_from_vcs(tag_prefix, root + else: + # HEX: no tags + pieces["closest-tag"] = None +- count_out = run_command(GITS, ["rev-list", "HEAD", "--count"], +- cwd=root) ++ count_out, rc = runner(GITS, ["rev-list", "HEAD", "--count"], cwd=root) + pieces["distance"] = int(count_out) # total number of commits + ++ # commit date: see ISO-8601 comment in git_versions_from_keywords() ++ date = runner(GITS, ["show", "-s", "--format=%%ci", "HEAD"], cwd=root)[0].strip() ++ # Use only the last line. Previous lines may contain GPG signature ++ # information. ++ date = date.splitlines()[-1] ++ pieces["date"] = date.strip().replace(" ", "T", 1).replace(" ", "", 1) ++ + return pieces + + + def plus_or_dot(pieces): ++ """Return a + if we don't already have one, else return a .""" + if "+" in pieces.get("closest-tag", ""): + return "." + return "+" + + + def render_pep440(pieces): +- # now build up version string, with post-release "local version +- # identifier". Our goal: TAG[+DISTANCE.gHEX[.dirty]] . Note that if you +- # get a tagged build and then dirty it, you'll get TAG+0.gHEX.dirty ++ """Build up version string, with post-release "local version identifier". + +- # exceptions: +- # 1: no tags. git_describe was just HEX. 0+untagged.DISTANCE.gHEX[.dirty] ++ Our goal: TAG[+DISTANCE.gHEX[.dirty]] . Note that if you ++ get a tagged build and then dirty it, you'll get TAG+0.gHEX.dirty + ++ Exceptions: ++ 1: no tags. git_describe was just HEX. 0+untagged.DISTANCE.gHEX[.dirty] ++ """ + if pieces["closest-tag"]: + rendered = pieces["closest-tag"] + if pieces["distance"] or pieces["dirty"]: +@@ -754,31 +796,80 @@ def render_pep440(pieces): + return rendered + + +-def render_pep440_pre(pieces): +- # TAG[.post.devDISTANCE] . No -dirty ++def render_pep440_branch(pieces): ++ """TAG[[.dev0]+DISTANCE.gHEX[.dirty]] . + +- # exceptions: +- # 1: no tags. 0.post.devDISTANCE ++ The ".dev0" means not master branch. Note that .dev0 sorts backwards ++ (a feature branch will appear "older" than the master branch). + ++ Exceptions: ++ 1: no tags. 0[.dev0]+untagged.DISTANCE.gHEX[.dirty] ++ """ + if pieces["closest-tag"]: + rendered = pieces["closest-tag"] ++ if pieces["distance"] or pieces["dirty"]: ++ if pieces["branch"] != "master": ++ rendered += ".dev0" ++ rendered += plus_or_dot(pieces) ++ rendered += "%%d.g%%s" %% (pieces["distance"], pieces["short"]) ++ if pieces["dirty"]: ++ rendered += ".dirty" ++ else: ++ # exception #1 ++ rendered = "0" ++ if pieces["branch"] != "master": ++ rendered += ".dev0" ++ rendered += "+untagged.%%d.g%%s" %% (pieces["distance"], ++ pieces["short"]) ++ if pieces["dirty"]: ++ rendered += ".dirty" ++ return rendered ++ ++ ++def pep440_split_post(ver): ++ """Split pep440 version string at the post-release segment. ++ ++ Returns the release segments before the post-release and the ++ post-release version number (or -1 if no post-release segment is present). ++ """ ++ vc = str.split(ver, ".post") ++ return vc[0], int(vc[1] or 0) if len(vc) == 2 else None ++ ++ ++def render_pep440_pre(pieces): ++ """TAG[.postN.devDISTANCE] -- No -dirty. ++ ++ Exceptions: ++ 1: no tags. 0.post0.devDISTANCE ++ """ ++ if pieces["closest-tag"]: + if pieces["distance"]: +- rendered += ".post.dev%%d" %% pieces["distance"] ++ # update the post release segment ++ tag_version, post_version = pep440_split_post(pieces["closest-tag"]) ++ rendered = tag_version ++ if post_version is not None: ++ rendered += ".post%%d.dev%%d" %% (post_version+1, pieces["distance"]) ++ else: ++ rendered += ".post0.dev%%d" %% (pieces["distance"]) ++ else: ++ # no commits, use the tag as the version ++ rendered = pieces["closest-tag"] + else: + # exception #1 +- rendered = "0.post.dev%%d" %% pieces["distance"] ++ rendered = "0.post0.dev%%d" %% pieces["distance"] + return rendered + + + def render_pep440_post(pieces): +- # TAG[.postDISTANCE[.dev0]+gHEX] . The ".dev0" means dirty. Note that +- # .dev0 sorts backwards (a dirty tree will appear "older" than the +- # corresponding clean one), but you shouldn't be releasing software with +- # -dirty anyways. +- +- # exceptions: +- # 1: no tags. 0.postDISTANCE[.dev0] ++ """TAG[.postDISTANCE[.dev0]+gHEX] . + ++ The ".dev0" means dirty. Note that .dev0 sorts backwards ++ (a dirty tree will appear "older" than the corresponding clean one), ++ but you shouldn't be releasing software with -dirty anyways. ++ ++ Exceptions: ++ 1: no tags. 0.postDISTANCE[.dev0] ++ """ + if pieces["closest-tag"]: + rendered = pieces["closest-tag"] + if pieces["distance"] or pieces["dirty"]: +@@ -796,12 +887,43 @@ def render_pep440_post(pieces): + return rendered + + ++def render_pep440_post_branch(pieces): ++ """TAG[.postDISTANCE[.dev0]+gHEX[.dirty]] . ++ ++ The ".dev0" means not master branch. ++ ++ Exceptions: ++ 1: no tags. 0.postDISTANCE[.dev0]+gHEX[.dirty] ++ """ ++ if pieces["closest-tag"]: ++ rendered = pieces["closest-tag"] ++ if pieces["distance"] or pieces["dirty"]: ++ rendered += ".post%%d" %% pieces["distance"] ++ if pieces["branch"] != "master": ++ rendered += ".dev0" ++ rendered += plus_or_dot(pieces) ++ rendered += "g%%s" %% pieces["short"] ++ if pieces["dirty"]: ++ rendered += ".dirty" ++ else: ++ # exception #1 ++ rendered = "0.post%%d" %% pieces["distance"] ++ if pieces["branch"] != "master": ++ rendered += ".dev0" ++ rendered += "+g%%s" %% pieces["short"] ++ if pieces["dirty"]: ++ rendered += ".dirty" ++ return rendered ++ ++ + def render_pep440_old(pieces): +- # TAG[.postDISTANCE[.dev0]] . The ".dev0" means dirty. ++ """TAG[.postDISTANCE[.dev0]] . + +- # exceptions: +- # 1: no tags. 0.postDISTANCE[.dev0] ++ The ".dev0" means dirty. + ++ Exceptions: ++ 1: no tags. 0.postDISTANCE[.dev0] ++ """ + if pieces["closest-tag"]: + rendered = pieces["closest-tag"] + if pieces["distance"] or pieces["dirty"]: +@@ -817,12 +939,13 @@ def render_pep440_old(pieces): + + + def render_git_describe(pieces): +- # TAG[-DISTANCE-gHEX][-dirty], like 'git describe --tags --dirty +- # --always' ++ """TAG[-DISTANCE-gHEX][-dirty]. + +- # exceptions: +- # 1: no tags. HEX[-dirty] (note: no 'g' prefix) ++ Like 'git describe --tags --dirty --always'. + ++ Exceptions: ++ 1: no tags. HEX[-dirty] (note: no 'g' prefix) ++ """ + if pieces["closest-tag"]: + rendered = pieces["closest-tag"] + if pieces["distance"]: +@@ -836,12 +959,14 @@ def render_git_describe(pieces): + + + def render_git_describe_long(pieces): +- # TAG-DISTANCE-gHEX[-dirty], like 'git describe --tags --dirty +- # --always -long'. The distance/hash is unconditional. ++ """TAG-DISTANCE-gHEX[-dirty]. + +- # exceptions: +- # 1: no tags. HEX[-dirty] (note: no 'g' prefix) ++ Like 'git describe --tags --dirty --always -long'. ++ The distance/hash is unconditional. + ++ Exceptions: ++ 1: no tags. HEX[-dirty] (note: no 'g' prefix) ++ """ + if pieces["closest-tag"]: + rendered = pieces["closest-tag"] + rendered += "-%%d-g%%s" %% (pieces["distance"], pieces["short"]) +@@ -854,21 +979,27 @@ def render_git_describe_long(pieces): + + + def render(pieces, style): ++ """Render the given version pieces into the requested style.""" + if pieces["error"]: + return {"version": "unknown", + "full-revisionid": pieces.get("long"), + "dirty": None, +- "error": pieces["error"]} ++ "error": pieces["error"], ++ "date": None} + + if not style or style == "default": + style = "pep440" # the default + + if style == "pep440": + rendered = render_pep440(pieces) ++ elif style == "pep440-branch": ++ rendered = render_pep440_branch(pieces) + elif style == "pep440-pre": + rendered = render_pep440_pre(pieces) + elif style == "pep440-post": + rendered = render_pep440_post(pieces) ++ elif style == "pep440-post-branch": ++ rendered = render_pep440_post_branch(pieces) + elif style == "pep440-old": + rendered = render_pep440_old(pieces) + elif style == "git-describe": +@@ -879,10 +1010,12 @@ def render(pieces, style): + raise ValueError("unknown style '%%s'" %% style) + + return {"version": rendered, "full-revisionid": pieces["long"], +- "dirty": pieces["dirty"], "error": None} ++ "dirty": pieces["dirty"], "error": None, ++ "date": pieces.get("date")} + + + def get_versions(): ++ """Get version information or return default if unable to do so.""" + # I am in _version.py, which lives at ROOT/VERSIONFILE_SOURCE. If we have + # __file__, we can work backwards from there to the root. Some + # py2exe/bbfreeze/non-CPython implementations don't do __file__, in which +@@ -902,12 +1035,13 @@ def get_versions(): + # versionfile_source is the relative path from the top of the source + # tree (where the .git directory might live) to this file. Invert + # this to find the root from __file__. +- for i in cfg.versionfile_source.split('/'): ++ for _ in cfg.versionfile_source.split('/'): + root = os.path.dirname(root) + except NameError: + return {"version": "0+unknown", "full-revisionid": None, + "dirty": None, +- "error": "unable to find root of source tree"} ++ "error": "unable to find root of source tree", ++ "date": None} + + try: + pieces = git_pieces_from_vcs(cfg.tag_prefix, root, verbose) +@@ -923,48 +1057,66 @@ def get_versions(): + + return {"version": "0+unknown", "full-revisionid": None, + "dirty": None, +- "error": "unable to compute version"} ++ "error": "unable to compute version", "date": None} + ''' + + + @register_vcs_handler("git", "get_keywords") + def git_get_keywords(versionfile_abs): ++ """Extract version information from the given file.""" + # the code embedded in _version.py can just fetch the value of these + # keywords. When used from setup.py, we don't want to import _version.py, + # so we do it with a regexp instead. This function is not used from + # _version.py. + keywords = {} + try: +- f = open(versionfile_abs, "r") +- for line in f.readlines(): +- if line.strip().startswith("git_refnames ="): +- mo = re.search(r'=\s*"(.*)"', line) +- if mo: +- keywords["refnames"] = mo.group(1) +- if line.strip().startswith("git_full ="): +- mo = re.search(r'=\s*"(.*)"', line) +- if mo: +- keywords["full"] = mo.group(1) +- f.close() +- except EnvironmentError: ++ with open(versionfile_abs, "r") as fobj: ++ for line in fobj: ++ if line.strip().startswith("git_refnames ="): ++ mo = re.search(r'=\s*"(.*)"', line) ++ if mo: ++ keywords["refnames"] = mo.group(1) ++ if line.strip().startswith("git_full ="): ++ mo = re.search(r'=\s*"(.*)"', line) ++ if mo: ++ keywords["full"] = mo.group(1) ++ if line.strip().startswith("git_date ="): ++ mo = re.search(r'=\s*"(.*)"', line) ++ if mo: ++ keywords["date"] = mo.group(1) ++ except OSError: + pass + return keywords + + + @register_vcs_handler("git", "keywords") + def git_versions_from_keywords(keywords, tag_prefix, verbose): +- if not keywords: +- raise NotThisMethod("no keywords at all, weird") ++ """Get version information from git keywords.""" ++ if "refnames" not in keywords: ++ raise NotThisMethod("Short version file found") ++ date = keywords.get("date") ++ if date is not None: ++ # Use only the last line. Previous lines may contain GPG signature ++ # information. ++ date = date.splitlines()[-1] ++ ++ # git-2.2.0 added "%cI", which expands to an ISO-8601 -compliant ++ # datestamp. However we prefer "%ci" (which expands to an "ISO-8601 ++ # -like" string, which we must then edit to make compliant), because ++ # it's been around since git-1.5.3, and it's too difficult to ++ # discover which version we're using, or to work around using an ++ # older one. ++ date = date.strip().replace(" ", "T", 1).replace(" ", "", 1) + refnames = keywords["refnames"].strip() + if refnames.startswith("$Format"): + if verbose: + print("keywords are unexpanded, not using") + raise NotThisMethod("unexpanded keywords, not a git-archive tarball") +- refs = set([r.strip() for r in refnames.strip("()").split(",")]) ++ refs = {r.strip() for r in refnames.strip("()").split(",")} + # starting in git-1.8.3, tags are listed as "tag: foo-1.0" instead of + # just "foo-1.0". If we see a "tag: " prefix, prefer those. + TAG = "tag: " +- tags = set([r[len(TAG):] for r in refs if r.startswith(TAG)]) ++ tags = {r[len(TAG):] for r in refs if r.startswith(TAG)} + if not tags: + # Either we're using git < 1.8.3, or there really are no tags. We use + # a heuristic: assume all version tags have a digit. The old git %d +@@ -973,54 +1125,67 @@ def git_versions_from_keywords(keywords, + # between branches and tags. By ignoring refnames without digits, we + # filter out many common branch names like "release" and + # "stabilization", as well as "HEAD" and "master". +- tags = set([r for r in refs if re.search(r'\d', r)]) ++ tags = {r for r in refs if re.search(r'\d', r)} + if verbose: +- print("discarding '%s', no digits" % ",".join(refs-tags)) ++ print("discarding '%s', no digits" % ",".join(refs - tags)) + if verbose: + print("likely tags: %s" % ",".join(sorted(tags))) + for ref in sorted(tags): + # sorting will prefer e.g. "2.0" over "2.0rc1" + if ref.startswith(tag_prefix): + r = ref[len(tag_prefix):] ++ # Filter out refs that exactly match prefix or that don't start ++ # with a number once the prefix is stripped (mostly a concern ++ # when prefix is '') ++ if not re.match(r'\d', r): ++ continue + if verbose: + print("picking %s" % r) + return {"version": r, + "full-revisionid": keywords["full"].strip(), +- "dirty": False, "error": None +- } ++ "dirty": False, "error": None, ++ "date": date} + # no suitable tags, so version is "0+unknown", but full hex is still there + if verbose: + print("no suitable tags, using unknown + full revision id") + return {"version": "0+unknown", + "full-revisionid": keywords["full"].strip(), +- "dirty": False, "error": "no suitable tags"} ++ "dirty": False, "error": "no suitable tags", "date": None} + + + @register_vcs_handler("git", "pieces_from_vcs") +-def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command): +- # this runs 'git' from the root of the source tree. This only gets called +- # if the git-archive 'subst' keywords were *not* expanded, and +- # _version.py hasn't already been rewritten with a short version string, +- # meaning we're inside a checked out source tree. +- +- if not os.path.exists(os.path.join(root, ".git")): +- if verbose: +- print("no .git in %s" % root) +- raise NotThisMethod("no .git directory") ++def git_pieces_from_vcs(tag_prefix, root, verbose, runner=run_command): ++ """Get version from 'git describe' in the root of the source tree. + ++ This only gets called if the git-archive 'subst' keywords were *not* ++ expanded, and _version.py hasn't already been rewritten with a short ++ version string, meaning we're inside a checked out source tree. ++ """ + GITS = ["git"] ++ TAG_PREFIX_REGEX = "*" + if sys.platform == "win32": + GITS = ["git.cmd", "git.exe"] +- # if there is a tag, this yields TAG-NUM-gHEX[-dirty] +- # if there are no tags, this yields HEX[-dirty] (no NUM) +- describe_out = run_command(GITS, ["describe", "--tags", "--dirty", +- "--always", "--long"], +- cwd=root) ++ TAG_PREFIX_REGEX = r"\*" ++ ++ _, rc = runner(GITS, ["rev-parse", "--git-dir"], cwd=root, ++ hide_stderr=True) ++ if rc != 0: ++ if verbose: ++ print("Directory %s not under git control" % root) ++ raise NotThisMethod("'git rev-parse --git-dir' returned error") ++ ++ # if there is a tag matching tag_prefix, this yields TAG-NUM-gHEX[-dirty] ++ # if there isn't one, this yields HEX[-dirty] (no NUM) ++ describe_out, rc = runner(GITS, ["describe", "--tags", "--dirty", ++ "--always", "--long", ++ "--match", ++ "%s%s" % (tag_prefix, TAG_PREFIX_REGEX)], ++ cwd=root) + # --long was added in git-1.5.5 + if describe_out is None: + raise NotThisMethod("'git describe' failed") + describe_out = describe_out.strip() +- full_out = run_command(GITS, ["rev-parse", "HEAD"], cwd=root) ++ full_out, rc = runner(GITS, ["rev-parse", "HEAD"], cwd=root) + if full_out is None: + raise NotThisMethod("'git rev-parse' failed") + full_out = full_out.strip() +@@ -1030,6 +1195,39 @@ def git_pieces_from_vcs(tag_prefix, root + pieces["short"] = full_out[:7] # maybe improved later + pieces["error"] = None + ++ branch_name, rc = runner(GITS, ["rev-parse", "--abbrev-ref", "HEAD"], ++ cwd=root) ++ # --abbrev-ref was added in git-1.6.3 ++ if rc != 0 or branch_name is None: ++ raise NotThisMethod("'git rev-parse --abbrev-ref' returned error") ++ branch_name = branch_name.strip() ++ ++ if branch_name == "HEAD": ++ # If we aren't exactly on a branch, pick a branch which represents ++ # the current commit. If all else fails, we are on a branchless ++ # commit. ++ branches, rc = runner(GITS, ["branch", "--contains"], cwd=root) ++ # --contains was added in git-1.5.4 ++ if rc != 0 or branches is None: ++ raise NotThisMethod("'git branch --contains' returned error") ++ branches = branches.split("\n") ++ ++ # Remove the first line if we're running detached ++ if "(" in branches[0]: ++ branches.pop(0) ++ ++ # Strip off the leading "* " from the list of branches. ++ branches = [branch[2:] for branch in branches] ++ if "master" in branches: ++ branch_name = "master" ++ elif not branches: ++ branch_name = None ++ else: ++ # Pick the first branch that is returned. Good or bad. ++ branch_name = branches[0] ++ ++ pieces["branch"] = branch_name ++ + # parse describe_out. It will be like TAG-NUM-gHEX[-dirty] or HEX[-dirty] + # TAG might have hyphens. + git_describe = describe_out +@@ -1046,7 +1244,7 @@ def git_pieces_from_vcs(tag_prefix, root + # TAG-NUM-gHEX + mo = re.search(r'^(.+)-(\d+)-g([0-9a-f]+)$', git_describe) + if not mo: +- # unparseable. Maybe git-describe is misbehaving? ++ # unparsable. Maybe git-describe is misbehaving? + pieces["error"] = ("unable to parse git-describe output: '%s'" + % describe_out) + return pieces +@@ -1071,14 +1269,25 @@ def git_pieces_from_vcs(tag_prefix, root + else: + # HEX: no tags + pieces["closest-tag"] = None +- count_out = run_command(GITS, ["rev-list", "HEAD", "--count"], +- cwd=root) ++ count_out, rc = runner(GITS, ["rev-list", "HEAD", "--count"], cwd=root) + pieces["distance"] = int(count_out) # total number of commits + ++ # commit date: see ISO-8601 comment in git_versions_from_keywords() ++ date = runner(GITS, ["show", "-s", "--format=%ci", "HEAD"], cwd=root)[0].strip() ++ # Use only the last line. Previous lines may contain GPG signature ++ # information. ++ date = date.splitlines()[-1] ++ pieces["date"] = date.strip().replace(" ", "T", 1).replace(" ", "", 1) ++ + return pieces + + + def do_vcs_install(manifest_in, versionfile_source, ipy): ++ """Git-specific installation logic for Versioneer. ++ ++ For Git, this means creating/changing .gitattributes to mark _version.py ++ for export-subst keyword substitution. ++ """ + GITS = ["git"] + if sys.platform == "win32": + GITS = ["git.cmd", "git.exe"] +@@ -1086,52 +1295,61 @@ def do_vcs_install(manifest_in, versionf + if ipy: + files.append(ipy) + try: +- me = __file__ +- if me.endswith(".pyc") or me.endswith(".pyo"): +- me = os.path.splitext(me)[0] + ".py" +- versioneer_file = os.path.relpath(me) ++ my_path = __file__ ++ if my_path.endswith(".pyc") or my_path.endswith(".pyo"): ++ my_path = os.path.splitext(my_path)[0] + ".py" ++ versioneer_file = os.path.relpath(my_path) + except NameError: + versioneer_file = "versioneer.py" + files.append(versioneer_file) + present = False + try: +- f = open(".gitattributes", "r") +- for line in f.readlines(): +- if line.strip().startswith(versionfile_source): +- if "export-subst" in line.strip().split()[1:]: +- present = True +- f.close() +- except EnvironmentError: ++ with open(".gitattributes", "r") as fobj: ++ for line in fobj: ++ if line.strip().startswith(versionfile_source): ++ if "export-subst" in line.strip().split()[1:]: ++ present = True ++ break ++ except OSError: + pass + if not present: +- f = open(".gitattributes", "a+") +- f.write("%s export-subst\n" % versionfile_source) +- f.close() ++ with open(".gitattributes", "a+") as fobj: ++ fobj.write(f"{versionfile_source} export-subst\n") + files.append(".gitattributes") + run_command(GITS, ["add", "--"] + files) + + + def versions_from_parentdir(parentdir_prefix, root, verbose): +- # Source tarballs conventionally unpack into a directory that includes +- # both the project name and a version string. +- dirname = os.path.basename(root) +- if not dirname.startswith(parentdir_prefix): +- if verbose: +- print("guessing rootdir is '%s', but '%s' doesn't start with " +- "prefix '%s'" % (root, dirname, parentdir_prefix)) +- raise NotThisMethod("rootdir doesn't start with parentdir_prefix") +- return {"version": dirname[len(parentdir_prefix):], +- "full-revisionid": None, +- "dirty": False, "error": None} ++ """Try to determine the version from the parent directory name. ++ ++ Source tarballs conventionally unpack into a directory that includes both ++ the project name and a version string. We will also support searching up ++ two directory levels for an appropriately named parent directory ++ """ ++ rootdirs = [] ++ ++ for _ in range(3): ++ dirname = os.path.basename(root) ++ if dirname.startswith(parentdir_prefix): ++ return {"version": dirname[len(parentdir_prefix):], ++ "full-revisionid": None, ++ "dirty": False, "error": None, "date": None} ++ rootdirs.append(root) ++ root = os.path.dirname(root) # up a level ++ ++ if verbose: ++ print("Tried directories %s but none started with prefix %s" % ++ (str(rootdirs), parentdir_prefix)) ++ raise NotThisMethod("rootdir doesn't start with parentdir_prefix") ++ + + SHORT_VERSION_PY = """ +-# This file was generated by 'versioneer.py' (0.15) from ++# This file was generated by 'versioneer.py' (0.21) from + # revision-control system data, or from the parent directory name of an + # unpacked source archive. Distribution tarballs contain a pre-generated copy + # of this file. + + import json +-import sys + + version_json = ''' + %s +@@ -1144,19 +1362,24 @@ def get_versions(): + + + def versions_from_file(filename): ++ """Try to determine the version from _version.py if present.""" + try: + with open(filename) as f: + contents = f.read() +- except EnvironmentError: ++ except OSError: + raise NotThisMethod("unable to read _version.py") + mo = re.search(r"version_json = '''\n(.*)''' # END VERSION_JSON", + contents, re.M | re.S) + if not mo: ++ mo = re.search(r"version_json = '''\r\n(.*)''' # END VERSION_JSON", ++ contents, re.M | re.S) ++ if not mo: + raise NotThisMethod("no version_json in _version.py") + return json.loads(mo.group(1)) + + + def write_to_version_file(filename, versions): ++ """Write the given version number to the given _version.py file.""" + os.unlink(filename) + contents = json.dumps(versions, sort_keys=True, + indent=1, separators=(",", ": ")) +@@ -1167,19 +1390,21 @@ def write_to_version_file(filename, vers + + + def plus_or_dot(pieces): ++ """Return a + if we don't already have one, else return a .""" + if "+" in pieces.get("closest-tag", ""): + return "." + return "+" + + + def render_pep440(pieces): +- # now build up version string, with post-release "local version +- # identifier". Our goal: TAG[+DISTANCE.gHEX[.dirty]] . Note that if you +- # get a tagged build and then dirty it, you'll get TAG+0.gHEX.dirty ++ """Build up version string, with post-release "local version identifier". + +- # exceptions: +- # 1: no tags. git_describe was just HEX. 0+untagged.DISTANCE.gHEX[.dirty] ++ Our goal: TAG[+DISTANCE.gHEX[.dirty]] . Note that if you ++ get a tagged build and then dirty it, you'll get TAG+0.gHEX.dirty + ++ Exceptions: ++ 1: no tags. git_describe was just HEX. 0+untagged.DISTANCE.gHEX[.dirty] ++ """ + if pieces["closest-tag"]: + rendered = pieces["closest-tag"] + if pieces["distance"] or pieces["dirty"]: +@@ -1196,31 +1421,80 @@ def render_pep440(pieces): + return rendered + + +-def render_pep440_pre(pieces): +- # TAG[.post.devDISTANCE] . No -dirty ++def render_pep440_branch(pieces): ++ """TAG[[.dev0]+DISTANCE.gHEX[.dirty]] . + +- # exceptions: +- # 1: no tags. 0.post.devDISTANCE ++ The ".dev0" means not master branch. Note that .dev0 sorts backwards ++ (a feature branch will appear "older" than the master branch). + ++ Exceptions: ++ 1: no tags. 0[.dev0]+untagged.DISTANCE.gHEX[.dirty] ++ """ + if pieces["closest-tag"]: + rendered = pieces["closest-tag"] ++ if pieces["distance"] or pieces["dirty"]: ++ if pieces["branch"] != "master": ++ rendered += ".dev0" ++ rendered += plus_or_dot(pieces) ++ rendered += "%d.g%s" % (pieces["distance"], pieces["short"]) ++ if pieces["dirty"]: ++ rendered += ".dirty" ++ else: ++ # exception #1 ++ rendered = "0" ++ if pieces["branch"] != "master": ++ rendered += ".dev0" ++ rendered += "+untagged.%d.g%s" % (pieces["distance"], ++ pieces["short"]) ++ if pieces["dirty"]: ++ rendered += ".dirty" ++ return rendered ++ ++ ++def pep440_split_post(ver): ++ """Split pep440 version string at the post-release segment. ++ ++ Returns the release segments before the post-release and the ++ post-release version number (or -1 if no post-release segment is present). ++ """ ++ vc = str.split(ver, ".post") ++ return vc[0], int(vc[1] or 0) if len(vc) == 2 else None ++ ++ ++def render_pep440_pre(pieces): ++ """TAG[.postN.devDISTANCE] -- No -dirty. ++ ++ Exceptions: ++ 1: no tags. 0.post0.devDISTANCE ++ """ ++ if pieces["closest-tag"]: + if pieces["distance"]: +- rendered += ".post.dev%d" % pieces["distance"] ++ # update the post release segment ++ tag_version, post_version = pep440_split_post(pieces["closest-tag"]) ++ rendered = tag_version ++ if post_version is not None: ++ rendered += ".post%d.dev%d" % (post_version+1, pieces["distance"]) ++ else: ++ rendered += ".post0.dev%d" % (pieces["distance"]) ++ else: ++ # no commits, use the tag as the version ++ rendered = pieces["closest-tag"] + else: + # exception #1 +- rendered = "0.post.dev%d" % pieces["distance"] ++ rendered = "0.post0.dev%d" % pieces["distance"] + return rendered + + + def render_pep440_post(pieces): +- # TAG[.postDISTANCE[.dev0]+gHEX] . The ".dev0" means dirty. Note that +- # .dev0 sorts backwards (a dirty tree will appear "older" than the +- # corresponding clean one), but you shouldn't be releasing software with +- # -dirty anyways. +- +- # exceptions: +- # 1: no tags. 0.postDISTANCE[.dev0] ++ """TAG[.postDISTANCE[.dev0]+gHEX] . + ++ The ".dev0" means dirty. Note that .dev0 sorts backwards ++ (a dirty tree will appear "older" than the corresponding clean one), ++ but you shouldn't be releasing software with -dirty anyways. ++ ++ Exceptions: ++ 1: no tags. 0.postDISTANCE[.dev0] ++ """ + if pieces["closest-tag"]: + rendered = pieces["closest-tag"] + if pieces["distance"] or pieces["dirty"]: +@@ -1238,12 +1512,43 @@ def render_pep440_post(pieces): + return rendered + + ++def render_pep440_post_branch(pieces): ++ """TAG[.postDISTANCE[.dev0]+gHEX[.dirty]] . ++ ++ The ".dev0" means not master branch. ++ ++ Exceptions: ++ 1: no tags. 0.postDISTANCE[.dev0]+gHEX[.dirty] ++ """ ++ if pieces["closest-tag"]: ++ rendered = pieces["closest-tag"] ++ if pieces["distance"] or pieces["dirty"]: ++ rendered += ".post%d" % pieces["distance"] ++ if pieces["branch"] != "master": ++ rendered += ".dev0" ++ rendered += plus_or_dot(pieces) ++ rendered += "g%s" % pieces["short"] ++ if pieces["dirty"]: ++ rendered += ".dirty" ++ else: ++ # exception #1 ++ rendered = "0.post%d" % pieces["distance"] ++ if pieces["branch"] != "master": ++ rendered += ".dev0" ++ rendered += "+g%s" % pieces["short"] ++ if pieces["dirty"]: ++ rendered += ".dirty" ++ return rendered ++ ++ + def render_pep440_old(pieces): +- # TAG[.postDISTANCE[.dev0]] . The ".dev0" means dirty. ++ """TAG[.postDISTANCE[.dev0]] . + +- # exceptions: +- # 1: no tags. 0.postDISTANCE[.dev0] ++ The ".dev0" means dirty. + ++ Exceptions: ++ 1: no tags. 0.postDISTANCE[.dev0] ++ """ + if pieces["closest-tag"]: + rendered = pieces["closest-tag"] + if pieces["distance"] or pieces["dirty"]: +@@ -1259,12 +1564,13 @@ def render_pep440_old(pieces): + + + def render_git_describe(pieces): +- # TAG[-DISTANCE-gHEX][-dirty], like 'git describe --tags --dirty +- # --always' ++ """TAG[-DISTANCE-gHEX][-dirty]. + +- # exceptions: +- # 1: no tags. HEX[-dirty] (note: no 'g' prefix) ++ Like 'git describe --tags --dirty --always'. + ++ Exceptions: ++ 1: no tags. HEX[-dirty] (note: no 'g' prefix) ++ """ + if pieces["closest-tag"]: + rendered = pieces["closest-tag"] + if pieces["distance"]: +@@ -1278,12 +1584,14 @@ def render_git_describe(pieces): + + + def render_git_describe_long(pieces): +- # TAG-DISTANCE-gHEX[-dirty], like 'git describe --tags --dirty +- # --always -long'. The distance/hash is unconditional. ++ """TAG-DISTANCE-gHEX[-dirty]. + +- # exceptions: +- # 1: no tags. HEX[-dirty] (note: no 'g' prefix) ++ Like 'git describe --tags --dirty --always -long'. ++ The distance/hash is unconditional. + ++ Exceptions: ++ 1: no tags. HEX[-dirty] (note: no 'g' prefix) ++ """ + if pieces["closest-tag"]: + rendered = pieces["closest-tag"] + rendered += "-%d-g%s" % (pieces["distance"], pieces["short"]) +@@ -1296,21 +1604,27 @@ def render_git_describe_long(pieces): + + + def render(pieces, style): ++ """Render the given version pieces into the requested style.""" + if pieces["error"]: + return {"version": "unknown", + "full-revisionid": pieces.get("long"), + "dirty": None, +- "error": pieces["error"]} ++ "error": pieces["error"], ++ "date": None} + + if not style or style == "default": + style = "pep440" # the default + + if style == "pep440": + rendered = render_pep440(pieces) ++ elif style == "pep440-branch": ++ rendered = render_pep440_branch(pieces) + elif style == "pep440-pre": + rendered = render_pep440_pre(pieces) + elif style == "pep440-post": + rendered = render_pep440_post(pieces) ++ elif style == "pep440-post-branch": ++ rendered = render_pep440_post_branch(pieces) + elif style == "pep440-old": + rendered = render_pep440_old(pieces) + elif style == "git-describe": +@@ -1321,16 +1635,19 @@ def render(pieces, style): + raise ValueError("unknown style '%s'" % style) + + return {"version": rendered, "full-revisionid": pieces["long"], +- "dirty": pieces["dirty"], "error": None} ++ "dirty": pieces["dirty"], "error": None, ++ "date": pieces.get("date")} + + + class VersioneerBadRootError(Exception): +- pass ++ """The project root directory is unknown or missing key files.""" + + + def get_versions(verbose=False): +- # returns dict with two keys: 'version' and 'full' ++ """Get the project version from whatever source is available. + ++ Returns dict with two keys: 'version' and 'full'. ++ """ + if "versioneer" in sys.modules: + # see the discussion in cmdclass.py:get_cmdclass() + del sys.modules["versioneer"] +@@ -1398,14 +1715,21 @@ def get_versions(verbose=False): + print("unable to compute version") + + return {"version": "0+unknown", "full-revisionid": None, +- "dirty": None, "error": "unable to compute version"} ++ "dirty": None, "error": "unable to compute version", ++ "date": None} + + + def get_version(): ++ """Get the short version string for this project.""" + return get_versions()["version"] + + +-def get_cmdclass(): ++def get_cmdclass(cmdclass=None): ++ """Get the custom setuptools/distutils subclasses used by Versioneer. ++ ++ If the package uses a different cmdclass (e.g. one from numpy), it ++ should be provide as an argument. ++ """ + if "versioneer" in sys.modules: + del sys.modules["versioneer"] + # this fixes the "python setup.py develop" case (also 'install' and +@@ -1419,9 +1743,9 @@ def get_cmdclass(): + # parent is protected against the child's "import versioneer". By + # removing ourselves from sys.modules here, before the child build + # happens, we protect the child from the parent's versioneer too. +- # Also see https://github.com/warner/python-versioneer/issues/52 ++ # Also see https://github.com/python-versioneer/python-versioneer/issues/52 + +- cmds = {} ++ cmds = {} if cmdclass is None else cmdclass.copy() + + # we add "version" to both distutils and setuptools + from distutils.core import Command +@@ -1442,6 +1766,7 @@ def get_cmdclass(): + print("Version: %s" % vers["version"]) + print(" full-revisionid: %s" % vers.get("full-revisionid")) + print(" dirty: %s" % vers.get("dirty")) ++ print(" date: %s" % vers.get("date")) + if vers["error"]: + print(" error: %s" % vers["error"]) + cmds["version"] = cmd_version +@@ -1455,8 +1780,19 @@ def get_cmdclass(): + # setuptools/bdist_egg -> distutils/install_lib -> build_py + # setuptools/install -> bdist_egg ->.. + # setuptools/develop -> ? +- +- from distutils.command.build_py import build_py as _build_py ++ # pip install: ++ # copies source tree to a tempdir before running egg_info/etc ++ # if .git isn't copied too, 'git describe' will fail ++ # then does setup.py bdist_wheel, or sometimes setup.py install ++ # setup.py egg_info -> ? ++ ++ # we override different "build_py" commands for both environments ++ if 'build_py' in cmds: ++ _build_py = cmds['build_py'] ++ elif "setuptools" in sys.modules: ++ from setuptools.command.build_py import build_py as _build_py ++ else: ++ from distutils.command.build_py import build_py as _build_py + + class cmd_build_py(_build_py): + def run(self): +@@ -1473,8 +1809,41 @@ def get_cmdclass(): + write_to_version_file(target_versionfile, versions) + cmds["build_py"] = cmd_build_py + ++ if 'build_ext' in cmds: ++ _build_ext = cmds['build_ext'] ++ elif "setuptools" in sys.modules: ++ from setuptools.command.build_ext import build_ext as _build_ext ++ else: ++ from distutils.command.build_ext import build_ext as _build_ext ++ ++ class cmd_build_ext(_build_ext): ++ def run(self): ++ root = get_root() ++ cfg = get_config_from_root(root) ++ versions = get_versions() ++ _build_ext.run(self) ++ if self.inplace: ++ # build_ext --inplace will only build extensions in ++ # build/lib<..> dir with no _version.py to write to. ++ # As in place builds will already have a _version.py ++ # in the module dir, we do not need to write one. ++ return ++ # now locate _version.py in the new build/ directory and replace ++ # it with an updated value ++ target_versionfile = os.path.join(self.build_lib, ++ cfg.versionfile_build) ++ print("UPDATING %s" % target_versionfile) ++ write_to_version_file(target_versionfile, versions) ++ cmds["build_ext"] = cmd_build_ext ++ + if "cx_Freeze" in sys.modules: # cx_freeze enabled? + from cx_Freeze.dist import build_exe as _build_exe ++ # nczeczulin reports that py2exe won't like the pep440-style string ++ # as FILEVERSION, but it can be used for PRODUCTVERSION, e.g. ++ # setup(console=[{ ++ # "version": versioneer.get_version().split("+", 1)[0], # FILEVERSION ++ # "product_version": versioneer.get_version(), ++ # ... + + class cmd_build_exe(_build_exe): + def run(self): +@@ -1499,8 +1868,35 @@ def get_cmdclass(): + cmds["build_exe"] = cmd_build_exe + del cmds["build_py"] + ++ if 'py2exe' in sys.modules: # py2exe enabled? ++ from py2exe.distutils_buildexe import py2exe as _py2exe ++ ++ class cmd_py2exe(_py2exe): ++ def run(self): ++ root = get_root() ++ cfg = get_config_from_root(root) ++ versions = get_versions() ++ target_versionfile = cfg.versionfile_source ++ print("UPDATING %s" % target_versionfile) ++ write_to_version_file(target_versionfile, versions) ++ ++ _py2exe.run(self) ++ os.unlink(target_versionfile) ++ with open(cfg.versionfile_source, "w") as f: ++ LONG = LONG_VERSION_PY[cfg.VCS] ++ f.write(LONG % ++ {"DOLLAR": "$", ++ "STYLE": cfg.style, ++ "TAG_PREFIX": cfg.tag_prefix, ++ "PARENTDIR_PREFIX": cfg.parentdir_prefix, ++ "VERSIONFILE_SOURCE": cfg.versionfile_source, ++ }) ++ cmds["py2exe"] = cmd_py2exe ++ + # we override different "sdist" commands for both environments +- if "setuptools" in sys.modules: ++ if 'sdist' in cmds: ++ _sdist = cmds['sdist'] ++ elif "setuptools" in sys.modules: + from setuptools.command.sdist import sdist as _sdist + else: + from distutils.command.sdist import sdist as _sdist +@@ -1539,7 +1935,7 @@ a section like: + style = pep440 + versionfile_source = src/myproject/_version.py + versionfile_build = myproject/_version.py +- tag_prefix = "" ++ tag_prefix = + parentdir_prefix = myproject- + + You will also need to edit your setup.py to use the results: +@@ -1567,20 +1963,26 @@ SAMPLE_CONFIG = """ + + """ + +-INIT_PY_SNIPPET = """ ++OLD_SNIPPET = """ + from ._version import get_versions + __version__ = get_versions()['version'] + del get_versions + """ + ++INIT_PY_SNIPPET = """ ++from . import {0} ++__version__ = {0}.get_versions()['version'] ++""" ++ + + def do_setup(): ++ """Do main VCS-independent setup function for installing Versioneer.""" + root = get_root() + try: + cfg = get_config_from_root(root) +- except (EnvironmentError, configparser.NoSectionError, ++ except (OSError, configparser.NoSectionError, + configparser.NoOptionError) as e: +- if isinstance(e, (EnvironmentError, configparser.NoSectionError)): ++ if isinstance(e, (OSError, configparser.NoSectionError)): + print("Adding sample versioneer config to setup.cfg", + file=sys.stderr) + with open(os.path.join(root, "setup.cfg"), "a") as f: +@@ -1604,12 +2006,18 @@ def do_setup(): + try: + with open(ipy, "r") as f: + old = f.read() +- except EnvironmentError: ++ except OSError: + old = "" +- if INIT_PY_SNIPPET not in old: ++ module = os.path.splitext(os.path.basename(cfg.versionfile_source))[0] ++ snippet = INIT_PY_SNIPPET.format(module) ++ if OLD_SNIPPET in old: ++ print(" replacing boilerplate in %s" % ipy) ++ with open(ipy, "w") as f: ++ f.write(old.replace(OLD_SNIPPET, snippet)) ++ elif snippet not in old: + print(" appending to %s" % ipy) + with open(ipy, "a") as f: +- f.write(INIT_PY_SNIPPET) ++ f.write(snippet) + else: + print(" %s unmodified" % ipy) + else: +@@ -1628,7 +2036,7 @@ def do_setup(): + if line.startswith("include "): + for include in line.split()[1:]: + simple_includes.add(include) +- except EnvironmentError: ++ except OSError: + pass + # That doesn't cover everything MANIFEST.in can do + # (http://docs.python.org/2/distutils/sourcedist.html#commands), so +@@ -1649,13 +2057,14 @@ def do_setup(): + print(" versionfile_source already in MANIFEST.in") + + # Make VCS-specific changes. For git, this means creating/changing +- # .gitattributes to mark _version.py for export-time keyword ++ # .gitattributes to mark _version.py for export-subst keyword + # substitution. + do_vcs_install(manifest_in, cfg.versionfile_source, ipy) + return 0 + + + def scan_setup_py(): ++ """Validate the contents of setup.py against Versioneer's expectations.""" + found = set() + setters = False + errors = 0 +@@ -1690,6 +2099,7 @@ def scan_setup_py(): + errors += 1 + return errors + ++ + if __name__ == "__main__": + cmd = sys.argv[1] + if cmd == "setup": +Index: ed25519-1.5/README.md +=================================================================== +--- ed25519-1.5.orig/README.md ++++ ed25519-1.5/README.md +@@ -33,8 +33,8 @@ and RSA-3072. + + This library includes a copy of all the C code necessary. You will need + Python 2.7 or Python 3.x (3.4 or later) and a C compiler. The tests are run +-automatically against python 2.7, 3.4, 3.5, 3.6, 3.7, and pypy versions of +-Python 2.7 and 3.6. ++automatically against python 2.7 and 3.4 onwards as well as pypy versions ++of Python 2.7 and 3.6 onwards. + + + ## Speed and Key Sizes diff --git a/fix-assertions.patch b/fix-assertions.patch new file mode 100644 index 0000000..6637c2b --- /dev/null +++ b/fix-assertions.patch @@ -0,0 +1,323 @@ +From ab351b6f80cf397921c7d5f09ca0a49e468d581a Mon Sep 17 00:00:00 2001 +From: Steve Kowalik +Date: Fri, 12 Jan 2024 13:21:13 +1100 +Subject: [PATCH] Switch to assert* rather than fail* + +The fail* methods from TestCase have been deprecated as of Python 3.1 +and 3.2, and were finally removed in Python 3.12. Switch to using the +non-deprecated assert* functions. +--- + src/ed25519/test_ed25519.py | 132 ++++++++++++++++++------------------ + test_ed25519_kat.py | 10 +-- + 2 files changed, 71 insertions(+), 71 deletions(-) + +diff --git a/src/ed25519/test_ed25519.py b/src/ed25519/test_ed25519.py +index 8dea618..ea018b4 100644 +--- a/src/ed25519/test_ed25519.py ++++ b/src/ed25519/test_ed25519.py +@@ -39,75 +39,75 @@ def log(self, msg): + def test_version(self): + # just make sure it can be retrieved + ver = ed25519.__version__ +- self.failUnless(isinstance(ver, type(""))) ++ self.assertTrue(isinstance(ver, type(""))) + + def test_constants(self): + # the secret key we get from raw.keypair() are 64 bytes long, and + # are mostly the output of a sha512 call. The first 32 bytes are the + # private exponent (random, with a few bits stomped). +- self.failUnlessEqual(raw.SECRETKEYBYTES, 64) ++ self.assertEqual(raw.SECRETKEYBYTES, 64) + # the public key is the encoded public point +- self.failUnlessEqual(raw.PUBLICKEYBYTES, 32) +- self.failUnlessEqual(raw.SIGNATUREKEYBYTES, 64) ++ self.assertEqual(raw.PUBLICKEYBYTES, 32) ++ self.assertEqual(raw.SIGNATUREKEYBYTES, 64) + + def test_raw(self): + sk_s = b"\x00" * 32 # usually urandom(32) + vk_s, skvk_s = raw.publickey(sk_s) +- self.failUnlessEqual(len(vk_s), 32) ++ self.assertEqual(len(vk_s), 32) + exp_vks = unhexlify(b"3b6a27bcceb6a42d62a3a8d02a6f0d73" + b"653215771de243a63ac048a18b59da29") +- self.failUnlessEqual(vk_s, exp_vks) +- self.failUnlessEqual(skvk_s[:32], sk_s) +- self.failUnlessEqual(skvk_s[32:], vk_s) ++ self.assertEqual(vk_s, exp_vks) ++ self.assertEqual(skvk_s[:32], sk_s) ++ self.assertEqual(skvk_s[32:], vk_s) + msg = b"hello world" + msg_and_sig = raw.sign(msg, skvk_s) + sig = msg_and_sig[:-len(msg)] +- self.failUnlessEqual(len(sig), 64) ++ self.assertEqual(len(sig), 64) + exp_sig = unhexlify(b"b0b47780f096ae60bfff8d8e7b19c36b" + b"321ae6e69cca972f2ff987ef30f20d29" + b"774b53bae404485c4391ddf1b3f37aaa" + b"8a9747f984eb0884e8aa533386e73305") +- self.failUnlessEqual(sig, exp_sig) ++ self.assertEqual(sig, exp_sig) + ret = raw.open(sig+msg, vk_s) # don't raise exception +- self.failUnlessEqual(ret, msg) +- self.failUnlessRaises(raw.BadSignatureError, ++ self.assertEqual(ret, msg) ++ self.assertRaises(raw.BadSignatureError, + raw.open, + sig+msg+b".. NOT!", vk_s) +- self.failUnlessRaises(raw.BadSignatureError, ++ self.assertRaises(raw.BadSignatureError, + raw.open, + sig+flip_bit(msg), vk_s) +- self.failUnlessRaises(raw.BadSignatureError, ++ self.assertRaises(raw.BadSignatureError, + raw.open, + sig+msg, flip_bit(vk_s)) +- self.failUnlessRaises(raw.BadSignatureError, ++ self.assertRaises(raw.BadSignatureError, + raw.open, + sig+msg, flip_bit(vk_s, in_byte=2)) +- self.failUnlessRaises(raw.BadSignatureError, ++ self.assertRaises(raw.BadSignatureError, + raw.open, + flip_bit(sig)+msg, vk_s) +- self.failUnlessRaises(raw.BadSignatureError, ++ self.assertRaises(raw.BadSignatureError, + raw.open, + flip_bit(sig, in_byte=33)+msg, vk_s) + + def test_keypair(self): + sk, vk = ed25519.create_keypair() +- self.failUnless(isinstance(sk, ed25519.SigningKey), sk) +- self.failUnless(isinstance(vk, ed25519.VerifyingKey), vk) ++ self.assertTrue(isinstance(sk, ed25519.SigningKey), sk) ++ self.assertTrue(isinstance(vk, ed25519.VerifyingKey), vk) + sk2, vk2 = ed25519.create_keypair() +- self.failIfEqual(hexlify(sk.to_bytes()), hexlify(sk2.to_bytes())) ++ self.assertNotEqual(hexlify(sk.to_bytes()), hexlify(sk2.to_bytes())) + + # you can control the entropy source + def not_so_random(length): + return b"4"*length + sk1, vk1 = ed25519.create_keypair(entropy=not_so_random) +- self.failUnlessEqual(sk1.to_ascii(encoding="base64"), ++ self.assertEqual(sk1.to_ascii(encoding="base64"), + b"NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ") +- self.failUnlessEqual(vk1.to_ascii(encoding="base64"), ++ self.assertEqual(vk1.to_ascii(encoding="base64"), + b"6yzxO/euOl9hQWih+wknLTl3HsS4UjcngV5GbK+O4WM") + sk2, vk2 = ed25519.create_keypair(entropy=not_so_random) +- self.failUnlessEqual(sk1.to_ascii(encoding="base64"), ++ self.assertEqual(sk1.to_ascii(encoding="base64"), + sk2.to_ascii(encoding="base64")) +- self.failUnlessEqual(vk1.to_ascii(encoding="base64"), ++ self.assertEqual(vk1.to_ascii(encoding="base64"), + vk2.to_ascii(encoding="base64")) + + +@@ -115,18 +115,18 @@ def test_publickey(self): + seed = unhexlify(b"4ba96b0b5303328c7405220598a587c4" + b"acb06ed9a9601d149f85400195f1ec3d") + sk = ed25519.SigningKey(seed) +- self.failUnlessEqual(hexlify(sk.to_bytes()), ++ self.assertEqual(hexlify(sk.to_bytes()), + (b"4ba96b0b5303328c7405220598a587c4" + b"acb06ed9a9601d149f85400195f1ec3d" + b"a66d161e090652b054740748f059f92a" + b"5b731f1c27b05571f6d942e4f8b7b264")) +- self.failUnlessEqual(hexlify(sk.to_seed()), ++ self.assertEqual(hexlify(sk.to_seed()), + (b"4ba96b0b5303328c7405220598a587c4" + b"acb06ed9a9601d149f85400195f1ec3d")) +- self.failUnlessRaises(ValueError, ++ self.assertRaises(ValueError, + ed25519.SigningKey, b"wrong length") + sk2 = ed25519.SigningKey(seed) +- self.failUnlessEqual(sk, sk2) ++ self.assertEqual(sk, sk2) + + def test_OOP(self): + sk_s = unhexlify(b"4ba96b0b5303328c7405220598a587c4" +@@ -134,30 +134,30 @@ def test_OOP(self): + b"a66d161e090652b054740748f059f92a" + b"5b731f1c27b05571f6d942e4f8b7b264") + sk = ed25519.SigningKey(sk_s) +- self.failUnlessEqual(len(sk.to_bytes()), 64) +- self.failUnlessEqual(sk.to_bytes(), sk_s) ++ self.assertEqual(len(sk.to_bytes()), 64) ++ self.assertEqual(sk.to_bytes(), sk_s) + + sk2_seed = unhexlify(b"4ba96b0b5303328c7405220598a587c4" + b"acb06ed9a9601d149f85400195f1ec3d") + sk2 = ed25519.SigningKey(sk2_seed) +- self.failUnlessEqual(sk2.to_bytes(), sk.to_bytes()) ++ self.assertEqual(sk2.to_bytes(), sk.to_bytes()) + + vk = sk.get_verifying_key() +- self.failUnlessEqual(len(vk.to_bytes()), 32) ++ self.assertEqual(len(vk.to_bytes()), 32) + exp_vks = unhexlify(b"a66d161e090652b054740748f059f92a" + b"5b731f1c27b05571f6d942e4f8b7b264") +- self.failUnlessEqual(vk.to_bytes(), exp_vks) +- self.failUnlessEqual(ed25519.VerifyingKey(vk.to_bytes()), vk) ++ self.assertEqual(vk.to_bytes(), exp_vks) ++ self.assertEqual(ed25519.VerifyingKey(vk.to_bytes()), vk) + msg = b"hello world" + sig = sk.sign(msg) +- self.failUnlessEqual(len(sig), 64) ++ self.assertEqual(len(sig), 64) + exp_sig = unhexlify(b"6eaffe94f2972b35158b6aaa9b69c1da" + b"97f0896aca29c41b1dd7b32e6c9e2ff6" + b"76fc8d8b034709cdcc37d8aeb86bebfb" + b"173ace3c319e211ea1d7e8d8884c1808") +- self.failUnlessEqual(sig, exp_sig) +- self.failUnlessEqual(vk.verify(sig, msg), None) # also, don't throw +- self.failUnlessRaises(ed25519.BadSignatureError, ++ self.assertEqual(sig, exp_sig) ++ self.assertEqual(vk.verify(sig, msg), None) # also, don't throw ++ self.assertRaises(ed25519.BadSignatureError, + vk.verify, sig, msg+b".. NOT!") + + def test_object_identity(self): +@@ -175,50 +175,50 @@ def test_object_identity(self): + vk1b = sk1b.get_verifying_key() + sk2 = ed25519.SigningKey(sk2_s) + vk2 = sk2.get_verifying_key() +- self.failUnlessEqual(sk1a, sk1b) +- self.failIfEqual(sk1a, sk2) +- self.failUnlessEqual(vk1a, vk1b) +- self.failIfEqual(vk1a, vk2) ++ self.assertEqual(sk1a, sk1b) ++ self.assertNotEqual(sk1a, sk2) ++ self.assertEqual(vk1a, vk1b) ++ self.assertNotEqual(vk1a, vk2) + +- self.failIfEqual(sk2, b"not a SigningKey") +- self.failIfEqual(vk2, b"not a VerifyingKey") ++ self.assertNotEqual(sk2, b"not a SigningKey") ++ self.assertNotEqual(vk2, b"not a VerifyingKey") + + def test_prefix(self): + sk1,vk1 = ed25519.create_keypair() + PREFIX = b"private0-" + p = sk1.to_bytes(PREFIX) + # that gives us a binary string with a prefix +- self.failUnless(p[:len(PREFIX)] == PREFIX, repr(p)) ++ self.assertTrue(p[:len(PREFIX)] == PREFIX, repr(p)) + sk2 = ed25519.SigningKey(p, prefix=PREFIX) +- self.failUnlessEqual(sk1, sk2) +- self.failUnlessEqual(repr(sk1.to_bytes()), repr(sk2.to_bytes())) +- self.failUnlessRaises(ed25519.BadPrefixError, ++ self.assertEqual(sk1, sk2) ++ self.assertEqual(repr(sk1.to_bytes()), repr(sk2.to_bytes())) ++ self.assertRaises(ed25519.BadPrefixError, + ed25519.SigningKey, p, prefix=b"WRONG-") + # SigningKey.to_seed() can do a prefix too + p = sk1.to_seed(PREFIX) +- self.failUnless(p[:len(PREFIX)] == PREFIX, repr(p)) ++ self.assertTrue(p[:len(PREFIX)] == PREFIX, repr(p)) + sk3 = ed25519.SigningKey(p, prefix=PREFIX) +- self.failUnlessEqual(sk1, sk3) +- self.failUnlessEqual(repr(sk1.to_bytes()), repr(sk3.to_bytes())) +- self.failUnlessRaises(ed25519.BadPrefixError, ++ self.assertEqual(sk1, sk3) ++ self.assertEqual(repr(sk1.to_bytes()), repr(sk3.to_bytes())) ++ self.assertRaises(ed25519.BadPrefixError, + ed25519.SigningKey, p, prefix=b"WRONG-") + + # verifying keys can do this too + PREFIX = b"public0-" + p = vk1.to_bytes(PREFIX) +- self.failUnless(p.startswith(PREFIX), repr(p)) ++ self.assertTrue(p.startswith(PREFIX), repr(p)) + vk2 = ed25519.VerifyingKey(p, prefix=PREFIX) +- self.failUnlessEqual(vk1, vk2) +- self.failUnlessEqual(repr(vk1.to_bytes()), repr(vk2.to_bytes())) +- self.failUnlessRaises(ed25519.BadPrefixError, ++ self.assertEqual(vk1, vk2) ++ self.assertEqual(repr(vk1.to_bytes()), repr(vk2.to_bytes())) ++ self.assertRaises(ed25519.BadPrefixError, + ed25519.VerifyingKey, p, prefix=b"WRONG-") + + # and signatures + PREFIX = b"sig0-" + p = sk1.sign(b"msg", PREFIX) +- self.failUnless(p.startswith(PREFIX), repr(p)) ++ self.assertTrue(p.startswith(PREFIX), repr(p)) + vk1.verify(p, b"msg", PREFIX) +- self.failUnlessRaises(ed25519.BadPrefixError, ++ self.assertRaises(ed25519.BadPrefixError, + vk1.verify, p, b"msg", prefix=b"WRONG-") + + def test_ascii(self): +@@ -230,7 +230,7 @@ def test_ascii(self): + for base in ("base64", "base32", "base16", "hex"): + a = b2a(b1, prefix, base) + b2 = a2b(a, prefix, base) +- self.failUnlessEqual(b1, b2) ++ self.assertEqual(b1, b2) + + def test_encoding(self): + sk_s = b"\x88" * 32 # usually urandom(32) +@@ -240,10 +240,10 @@ def test_encoding(self): + def check1(encoding, expected): + PREFIX = "private0-" + p = sk1.to_ascii(PREFIX, encoding) +- self.failUnlessEqual(p, expected) ++ self.assertEqual(p, expected) + sk2 = ed25519.SigningKey(p, prefix=PREFIX, encoding=encoding) +- self.failUnlessEqual(repr(sk1.to_bytes()), repr(sk2.to_bytes())) +- self.failUnlessEqual(sk1, sk2) ++ self.assertEqual(repr(sk1.to_bytes()), repr(sk2.to_bytes())) ++ self.assertEqual(sk1, sk2) + check1("base64", b"private0-iIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIg") + check1("base32", b"private0-rceirceirceirceirceirceirceirceirceirceirceirceircea") + check1("hex", b"private0-8888888888888888888888888888888888888888888888888888888888888888") +@@ -251,10 +251,10 @@ def check1(encoding, expected): + def check2(encoding, expected): + PREFIX="public0-" + p = vk1.to_ascii(PREFIX, encoding) +- self.failUnlessEqual(p, expected) ++ self.assertEqual(p, expected) + vk2 = ed25519.VerifyingKey(p, prefix=PREFIX, encoding=encoding) +- self.failUnlessEqual(repr(vk1.to_bytes()), repr(vk2.to_bytes())) +- self.failUnlessEqual(vk1, vk2) ++ self.assertEqual(repr(vk1.to_bytes()), repr(vk2.to_bytes())) ++ self.assertEqual(vk1, vk2) + check2("base64", b"public0-skkdlQKuKGMKK6yy4MdFEP/N0yjDNP8+E5PnWy0x59w") + check2("base32", b"public0-wjer3ficvyuggcrlvszobr2fcd743uziym2p6pqtsptvwljr47oa") + check2("hex", b"public0-b2491d9502ae28630a2bacb2e0c74510ffcdd328c334ff3e1393e75b2d31e7dc") +@@ -263,7 +263,7 @@ def check3(encoding, expected): + msg = b"msg" + PREFIX="sig0-" + sig = sk1.sign(msg, PREFIX, encoding) +- self.failUnlessEqual(sig, expected) ++ self.assertEqual(sig, expected) + vk1.verify(sig, msg, PREFIX, encoding) + check3("base64", b"sig0-MNfdUir6tMlaYQ+/p8KANJ5d+bk8g2al76v5MeJCo6RiywxURda3sU580CyiW2FBG/Q7kDRswgYqxbkQw3o5CQ") + check3("base32", b"sig0-gdl52urk7k2mswtbb672pquagspf36nzhsbwnjppvp4tdyscuosgfsymkrc5nn5rjz6nalfclnqucg7uhoidi3gcayvmloiqyn5dsci") +diff --git a/test_ed25519_kat.py b/test_ed25519_kat.py +index 95a0925..148598a 100644 +--- a/test_ed25519_kat.py ++++ b/test_ed25519_kat.py +@@ -29,15 +29,15 @@ def test_all(self): + + sk = ed25519.SigningKey(seed) + vk = sk.get_verifying_key() +- self.failUnlessEqual(vk.to_bytes(), vk_s) ++ self.assertEqual(vk.to_bytes(), vk_s) + vk2 = ed25519.VerifyingKey(vk_s) +- self.failUnlessEqual(vk2, vk) # objects should compare equal +- self.failUnlessEqual(vk2.to_bytes(), vk_s) ++ self.assertEqual(vk2, vk) # objects should compare equal ++ self.assertEqual(vk2.to_bytes(), vk_s) + newsig = sk.sign(msg) + sig_R,sig_S = sig[:32],sig[32:] + newsig_R,newsig_S = newsig[:32],newsig[32:] +- self.failUnlessEqual(hexlify(newsig), hexlify(sig)) # deterministic sigs +- self.failUnlessEqual(vk.verify(sig, msg), None) # no exception ++ self.assertEqual(hexlify(newsig), hexlify(sig)) # deterministic sigs ++ self.assertIsNone(vk.verify(sig, msg)) # no exception + + + if __name__ == '__main__': diff --git a/python-ed25519.changes b/python-ed25519.changes index 68e1036..4c920a1 100644 --- a/python-ed25519.changes +++ b/python-ed25519.changes @@ -1,3 +1,11 @@ +------------------------------------------------------------------- +Fri Jan 12 02:27:28 UTC 2024 - Steve Kowalik + +- Switch to autosetup and pyproject macros. +- Stop using greedy globs in %files. +- Add patches bump-versioneer.patch and fix-assertions.patch: + * Support Python 3.12 changes. + ------------------------------------------------------------------- Thu Oct 7 15:11:01 UTC 2021 - Matej Cepl diff --git a/python-ed25519.spec b/python-ed25519.spec index dee2a0c..031c669 100644 --- a/python-ed25519.spec +++ b/python-ed25519.spec @@ -1,7 +1,7 @@ # # spec file for package python-ed25519 # -# Copyright (c) 2021 SUSE LLC +# Copyright (c) 2024 SUSE LLC # # All modifications and additions to the file contributed by third parties # remain the property of their copyright owners, unless otherwise agreed @@ -16,17 +16,21 @@ # -%{?!python_module:%define python_module() python-%{**} python3-%{**}} Name: python-ed25519 Version: 1.5 Release: 0 Summary: Python bindings to the Ed25519 public-key signature system License: MIT -Group: Development/Languages/Python URL: https://github.com/warner/python-ed25519 Source: https://files.pythonhosted.org/packages/source/e/ed25519/ed25519-%{version}.tar.gz +# PATCH-FIX-UPSTREAM Based on gh#warner/python-ed25519#16 +Patch0: bump-versioneer.patch +# PATCH-FIX-UPSTREAM gh#warner/python-ed25519#21 +Patch1: fix-assertions.patch BuildRequires: %{python_module devel} +BuildRequires: %{python_module pip} BuildRequires: %{python_module setuptools} +BuildRequires: %{python_module wheel} BuildRequires: fdupes BuildRequires: python-rpm-macros Requires(post): update-alternatives @@ -37,14 +41,14 @@ Requires(postun):update-alternatives Python bindings to the Ed25519 public-key signature system. %prep -%setup -q -n ed25519-%{version} +%autosetup -p1 -n ed25519-%{version} %build export CFLAGS="%{optflags}" -%python_build +%pyproject_wheel %install -%python_install +%pyproject_install %python_clone -a %{buildroot}%{_bindir}/edsig %python_expand %fdupes %{buildroot}%{$python_sitearch} @@ -63,6 +67,7 @@ rm -r src %doc NEWS README.md %license LICENSE %python_alternative %{_bindir}/edsig -%{python_sitearch}/* +%{python_sitearch}/ed25519 +%{python_sitearch}/ed25519-%{version}.dist-info %changelog