From 195ce20a804f15729b8b028d6bf6923995741eef Mon Sep 17 00:00:00 2001 From: Jerry James Date: Dec 20 2021 23:10:00 +0000 Subject: Add -versioneer patch to fix FTBFS with python 3.11. --- diff --git a/README.md b/README.md index d1642f4..5eb3a2a 100644 --- a/README.md +++ b/README.md @@ -1,3 +1,6 @@ # python-nb2plots -The python-nb2plots package \ No newline at end of file +The [nb2plots package](https://matthew-brett.github.io/nb2plots/) contains +tools for converting from [Jupyter](https://jupyter.org/) notebooks to +[ReST](https://docutils.sourceforge.io/rst.html) for +[Sphinx](https://www.sphinx-doc.org/), and vice versa. diff --git a/python-nb2plots-versioneer.patch b/python-nb2plots-versioneer.patch new file mode 100644 index 0000000..151c03c --- /dev/null +++ b/python-nb2plots-versioneer.patch @@ -0,0 +1,1321 @@ +--- a/versioneer.py 2020-12-24 19:00:10.000000000 -0700 ++++ b/versioneer.py 2021-11-19 10:39:27.750410356 -0700 +@@ -1,5 +1,5 @@ + +-# Version: 0.17 ++# Version: 0.21 + + """The Versioneer - like a rocketeer, but for versions. + +@@ -7,16 +7,12 @@ 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, 3.5, 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 +@@ -27,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 + +@@ -61,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: + +@@ -151,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 + +@@ -166,7 +163,7 @@ which may help identify what went wrong) + + 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/warner/python-versioneer/issues). ++[issues page](https://github.com/python-versioneer/python-versioneer/issues). + + ### Subprojects + +@@ -180,7 +177,7 @@ two common reasons why `setup.py` might + `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 langauges) in subdirectories. ++ 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 +@@ -194,9 +191,9 @@ 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/warner/python-versioneer/issues/38) is tracking ++[Bug #38](https://github.com/python-versioneer/python-versioneer/issues/38) is tracking + this issue. The discussion in +-[PR #61](https://github.com/warner/python-versioneer/pull/61) describes the ++[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 +@@ -224,22 +221,10 @@ regenerated while a different version is + 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/warner/python-versioneer/issues/83) describes ++[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. + +-### Unicode version strings +- +-While Versioneer works (and is continually tested) with both Python 2 and +-Python 3, it is not entirely consistent with bytes-vs-unicode distinctions. +-Newer releases probably generate unicode version strings on py2. It's not +-clear that this is wrong, but it may be surprising for applications when then +-write these strings to a network connection or include them in bytes-oriented +-APIs like cryptographic checksums. +- +-[Bug #71](https://github.com/warner/python-versioneer/issues/71) investigates +-this question. +- + + ## Updating Versioneer + +@@ -265,6 +250,14 @@ 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 + +@@ -274,19 +267,27 @@ Specifically, both are released under th + 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: +@@ -321,12 +322,12 @@ 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__)) +- me_dir = os.path.normcase(os.path.splitext(me)[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 +@@ -334,48 +335,46 @@ def get_root(): + + def get_config_from_root(root): + """Read the project setup.cfg file to determine Versioneer config.""" +- # This might raise EnvironmentError (if setup.cfg is missing), or ++ # 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.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 = get(parser, "parentdir_prefix") +- cfg.verbose = get(parser, "verbose") ++ cfg.parentdir_prefix = section.get("parentdir_prefix") ++ cfg.verbose = section.get("verbose") + return cfg + + + class NotThisMethod(Exception): + """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 +- """Decorator to mark a method as the handler for a particular VCS.""" ++ """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 ++ HANDLERS.setdefault(vcs, {})[method] = f + return f + return decorate + +@@ -384,17 +383,17 @@ def run_command(commands, args, cwd=None + 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, env=env, +- 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 +@@ -406,16 +405,16 @@ def run_command(commands, args, cwd=None + if verbose: + print("unable to find command, tried %s" % (commands,)) + return None, None +- stdout = p.communicate()[0].strip() +- if sys.version_info[0] >= 3: +- stdout = stdout.decode() +- if p.returncode != 0: ++ stdout = process.communicate()[0].strip().decode() ++ if process.returncode != 0: + if verbose: + print("unable to run %s (error)" % dispcmd) + print("stdout was %s" % stdout) +- return None, p.returncode +- return stdout, p.returncode +-LONG_VERSION_PY['git'] = ''' ++ 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 +@@ -423,7 +422,7 @@ LONG_VERSION_PY['git'] = ''' + # that just contains the computed version number. + + # This file is released into the public domain. Generated by +-# versioneer-0.17 (https://github.com/warner/python-versioneer) ++# versioneer-0.21 (https://github.com/python-versioneer/python-versioneer) + + """Git implementation of _version.py.""" + +@@ -432,6 +431,7 @@ import os + import re + import subprocess + import sys ++from typing import Callable, Dict + + + def get_keywords(): +@@ -469,12 +469,12 @@ class NotThisMethod(Exception): + """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 +- """Decorator to mark a method as the handler for a particular VCS.""" ++ """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: +@@ -488,17 +488,17 @@ def run_command(commands, args, cwd=None + 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, env=env, +- 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 +@@ -510,15 +510,13 @@ def run_command(commands, args, cwd=None + if verbose: + print("unable to find command, tried %%s" %% (commands,)) + return None, None +- stdout = p.communicate()[0].strip() +- if sys.version_info[0] >= 3: +- stdout = stdout.decode() +- if p.returncode != 0: ++ stdout = process.communicate()[0].strip().decode() ++ if process.returncode != 0: + if verbose: + print("unable to run %%s (error)" %% dispcmd) + print("stdout was %%s" %% stdout) +- return None, p.returncode +- return stdout, p.returncode ++ return None, process.returncode ++ return stdout, process.returncode + + + def versions_from_parentdir(parentdir_prefix, root, verbose): +@@ -530,15 +528,14 @@ def versions_from_parentdir(parentdir_pr + """ + rootdirs = [] + +- for i in range(3): ++ 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} +- else: +- rootdirs.append(root) +- root = os.path.dirname(root) # up a level ++ rootdirs.append(root) ++ root = os.path.dirname(root) # up a level + + if verbose: + print("Tried directories %%s but none started with prefix %%s" %% +@@ -555,22 +552,21 @@ def git_get_keywords(versionfile_abs): + # _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) +- if line.strip().startswith("git_date ="): +- mo = re.search(r'=\s*"(.*)"', line) +- if mo: +- keywords["date"] = 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 + +@@ -578,10 +574,14 @@ def git_get_keywords(versionfile_abs): + @register_vcs_handler("git", "keywords") + def git_versions_from_keywords(keywords, tag_prefix, verbose): + """Get version information from git keywords.""" +- if not keywords: +- raise NotThisMethod("no keywords at all, weird") ++ 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 +@@ -594,11 +594,11 @@ def git_versions_from_keywords(keywords, + 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 +@@ -607,7 +607,7 @@ 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)) + if verbose: +@@ -616,6 +616,11 @@ def git_versions_from_keywords(keywords, + # 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, +@@ -631,7 +636,7 @@ def git_versions_from_keywords(keywords, + + + @register_vcs_handler("git", "pieces_from_vcs") +-def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command): ++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* +@@ -639,11 +644,13 @@ def git_pieces_from_vcs(tag_prefix, root + 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"] ++ TAG_PREFIX_REGEX = r"\*" + +- out, rc = run_command(GITS, ["rev-parse", "--git-dir"], cwd=root, +- hide_stderr=True) ++ _, 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) +@@ -651,15 +658,16 @@ def git_pieces_from_vcs(tag_prefix, root + + # 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 = run_command(GITS, ["describe", "--tags", "--dirty", +- "--always", "--long", +- "--match", "%%s*" %% tag_prefix], +- cwd=root) ++ 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, rc = 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() +@@ -669,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 +@@ -685,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 +@@ -710,13 +751,14 @@ def git_pieces_from_vcs(tag_prefix, root + else: + # HEX: no tags + pieces["closest-tag"] = None +- count_out, rc = 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 = run_command(GITS, ["show", "-s", "--format=%%ci", "HEAD"], +- cwd=root)[0].strip() ++ 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 +@@ -754,19 +796,67 @@ 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]] . ++ ++ 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.post.devDISTANCE ++ 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 + + +@@ -797,12 +887,41 @@ 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. + +- Eexceptions: ++ Exceptions: + 1: no tags. 0.postDISTANCE[.dev0] + """ + if pieces["closest-tag"]: +@@ -873,10 +992,14 @@ def render(pieces, style): + + 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": +@@ -912,7 +1035,7 @@ 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, +@@ -947,22 +1070,21 @@ def git_get_keywords(versionfile_abs): + # _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) +- if line.strip().startswith("git_date ="): +- mo = re.search(r'=\s*"(.*)"', line) +- if mo: +- keywords["date"] = 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 + +@@ -970,10 +1092,14 @@ def git_get_keywords(versionfile_abs): + @register_vcs_handler("git", "keywords") + def git_versions_from_keywords(keywords, tag_prefix, verbose): + """Get version information from git keywords.""" +- if not keywords: +- raise NotThisMethod("no keywords at all, weird") ++ 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 +@@ -986,11 +1112,11 @@ def git_versions_from_keywords(keywords, + 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 +@@ -999,7 +1125,7 @@ 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)) + if verbose: +@@ -1008,6 +1134,11 @@ def git_versions_from_keywords(keywords, + # 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, +@@ -1023,7 +1154,7 @@ def git_versions_from_keywords(keywords, + + + @register_vcs_handler("git", "pieces_from_vcs") +-def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command): ++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* +@@ -1031,11 +1162,13 @@ def git_pieces_from_vcs(tag_prefix, root + 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"] ++ TAG_PREFIX_REGEX = r"\*" + +- out, rc = run_command(GITS, ["rev-parse", "--git-dir"], cwd=root, +- hide_stderr=True) ++ _, 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) +@@ -1043,15 +1176,16 @@ def git_pieces_from_vcs(tag_prefix, root + + # 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 = run_command(GITS, ["describe", "--tags", "--dirty", +- "--always", "--long", +- "--match", "%s*" % tag_prefix], +- cwd=root) ++ 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, rc = 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() +@@ -1061,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 +@@ -1077,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 +@@ -1102,13 +1269,14 @@ def git_pieces_from_vcs(tag_prefix, root + else: + # HEX: no tags + pieces["closest-tag"] = None +- count_out, rc = 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 = run_command(GITS, ["show", "-s", "--format=%ci", "HEAD"], +- cwd=root)[0].strip() ++ 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 +@@ -1127,27 +1295,26 @@ 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) + +@@ -1161,23 +1328,23 @@ def versions_from_parentdir(parentdir_pr + """ + rootdirs = [] + +- for i in range(3): ++ 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} +- else: +- rootdirs.append(root) +- root = os.path.dirname(root) # up a level ++ 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.17) 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. +@@ -1199,7 +1366,7 @@ def versions_from_file(filename): + 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) +@@ -1254,19 +1421,67 @@ 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]] . ++ ++ 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.post.devDISTANCE ++ 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 + + +@@ -1297,12 +1512,41 @@ 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. + +- Eexceptions: ++ Exceptions: + 1: no tags. 0.postDISTANCE[.dev0] + """ + if pieces["closest-tag"]: +@@ -1373,10 +1617,14 @@ def render(pieces, style): + + 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": +@@ -1476,8 +1724,12 @@ def get_version(): + return get_versions()["version"] + + +-def get_cmdclass(): +- """Get the custom setuptools/distutils subclasses used by Versioneer.""" ++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 +@@ -1491,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 +@@ -1535,7 +1787,9 @@ def get_cmdclass(): + # setup.py egg_info -> ? + + # we override different "build_py" commands for both environments +- if "setuptools" in sys.modules: ++ 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 +@@ -1555,6 +1809,33 @@ 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 +@@ -1588,10 +1869,7 @@ def get_cmdclass(): + del cmds["build_py"] + + if 'py2exe' in sys.modules: # py2exe enabled? +- try: +- from py2exe.distutils_buildexe import py2exe as _py2exe # py3 +- except ImportError: +- from py2exe.build_exe import py2exe as _py2exe # py2 ++ from py2exe.distutils_buildexe import py2exe as _py2exe + + class cmd_py2exe(_py2exe): + def run(self): +@@ -1616,7 +1894,9 @@ def get_cmdclass(): + 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 +@@ -1683,21 +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(): +- """Main VCS-independent setup function for installing Versioneer.""" ++ """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: +@@ -1721,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: +@@ -1745,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 +@@ -1808,6 +2099,7 @@ def scan_setup_py(): + errors += 1 + return errors + ++ + if __name__ == "__main__": + cmd = sys.argv[1] + if cmd == "setup": diff --git a/python-nb2plots.spec b/python-nb2plots.spec index a72fe53..5df51be 100644 --- a/python-nb2plots.spec +++ b/python-nb2plots.spec @@ -8,13 +8,16 @@ Name: python-%{srcname} Version: 0.6 -Release: 17.%{gitdate}.%{shortcommit}%{?dist} +Release: 18.%{gitdate}.%{shortcommit}%{?dist} Summary: Convert between Jupyter notebooks and sphinx docs License: BSD URL: https://matthew-brett.github.io/nb2plots/ #Source0: https://github.com/matthew-brett/%%{srcname}/archive/%%{version}/%%{srcname}-%%{version}.tar.gz Source0: https://github.com/matthew-brett/%{srcname}/archive/%{commit}/%{srcname}-%{shortcommit}.tar.gz +# Update versioneer.py to fix FTBFS with python 3.11 +# See https://github.com/matthew-brett/nb2plots/issues/18 +Patch0: %{name}-versioneer.patch BuildArch: noarch BuildRequires: python3-devel @@ -26,6 +29,7 @@ BuildRequires: %{py3_dist nbconvert} BuildRequires: %{py3_dist netifaces} BuildRequires: %{py3_dist numpy} BuildRequires: %{py3_dist numpydoc} +BuildRequires: %{py3_dist pip} BuildRequires: %{py3_dist pytest} BuildRequires: %{py3_dist scripttester} BuildRequires: %{py3_dist setuptools} @@ -33,6 +37,7 @@ BuildRequires: %{py3_dist six} BuildRequires: %{py3_dist sphinx} BuildRequires: %{py3_dist sphinxtesters} BuildRequires: %{py3_dist texext} +BuildRequires: %{py3_dist wheel} BuildRequires: help2man BuildRequires: latexmk @@ -84,7 +89,8 @@ sed -i '/#!python/d' nb2plots/from_notebook.py sed -i 's/HEAD -> master/tag: %{version}/' nb2plots/_version.py %build -%py3_build +%pyproject_wheel +pathfix.py -pni %{python3} build/scripts-*/* # Documentation build export PATH=$PWD/build/scripts-%{python3_version}:$PATH @@ -99,7 +105,7 @@ for m in nb2plots rst2md sphinx2md sphinx2nb sphinx2pxml sphinx2py; do done %install -%py3_install +%pyproject_install # Install the man pages mkdir -p %{buildroot}%{_mandir} @@ -124,6 +130,9 @@ cp -a man1 %{buildroot}%{_mandir} %doc doc/_build/html/* %changelog +* Mon Dec 20 2021 Jerry James - 0.6-18.20201224.1a7bac4 +- Add -versioneer patch to fix FTBFS with python 3.11 + * Fri Jul 23 2021 Fedora Release Engineering - 0.6-17.20201224.1a7bac4 - Rebuilt for https://fedoraproject.org/wiki/Fedora_35_Mass_Rebuild