@@ -1,520 +1,169 @@

-

-# 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

-# directories (produced by setup.py build) will contain a much shorter file

-# that just contains the computed version number.

-

-# This file is released into the public domain. Generated by

-# versioneer-0.18 (https://github.com/warner/python-versioneer)

-

-"""Git implementation of _version.py."""

-

-import errno

+# -*- coding: utf-8 -*-

+# This file is part of 'miniver': https://github.com/jbweston/miniver

+#

+from collections import namedtuple

 import os

-import re

 import subprocess

 import sys

+from distutils.command.build import build as build_orig

+from setuptools.command.sdist import sdist as sdist_orig

-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 = "$Format:%d$"

-    git_full = "$Format:%H$"

-    git_date = "$Format:%ci$"

-    keywords = {"refnames": git_refnames, "full": git_full, "date": git_date}

-    return keywords

+Version = namedtuple('Version', ('release', 'dev', 'labels'))

+# No public API

+__all__ = []

-class VersioneerConfig:

-    """Container for Versioneer configuration parameters."""

+package_root = os.path.dirname(os.path.realpath(__file__))

+package_name = os.path.basename(package_root)

+distr_root = os.path.dirname(package_root)

+STATIC_VERSION_FILE = '_static_version.py'

-def get_config():

-    """Create, populate and return the VersioneerConfig() object."""

-    # these strings are filled in when 'setup.py versioneer' creates

-    # _version.py

-    cfg = VersioneerConfig()

-    cfg.VCS = "git"

-    cfg.style = "pep440"

-    cfg.tag_prefix = ""

-    cfg.parentdir_prefix = "nord-"

-    cfg.versionfile_source = "nord/_version.py"

-    cfg.verbose = False

-    return cfg

+def get_version(version_file=STATIC_VERSION_FILE):

+    version_info = {}

+    with open(os.path.join(package_root, version_file), 'rb') as f:

+        exec(f.read(), {}, version_info)

+    version = version_info['version']

+    version_is_from_git = (version == "__use_git__")

+    if version_is_from_git:

+        version = get_version_from_git()

+        if not version:

+            version = get_version_from_git_archive(version_info)

+        if not version:

+            version = Version("unknown", None, None)

+        return semver_format(version)

+    else:

+        return version

-class NotThisMethod(Exception):

-    """Exception raised if a method is not valid for the current scenario."""

+def semver_format(version_info):

+    release, dev, labels = version_info

-LONG_VERSION_PY = {}

-HANDLERS = {}

+    version_parts = [release]

+    if dev:

+        if release.endswith('-dev'):

+            version_parts.append(dev)

+        elif release.contains('-'):

+            version_parts.append('.dev{}'.format(dev))

+        else:

+            version_parts.append('-dev{}'.format(dev))

+    if labels:

+        version_parts.append('+')

+        version_parts.append(".".join(labels))

-def register_vcs_handler(vcs, method):  # decorator

-    """Decorator to mark a method as the handler for a particular VCS."""

-    def decorate(f):

-        """Store f in HANDLERS[vcs][method]."""

-        if vcs not in HANDLERS:

-            HANDLERS[vcs] = {}

-        HANDLERS[vcs][method] = f

-        return f

-    return decorate

+    return "".join(version_parts)

-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:

+def get_version_from_git():

+    try:

+        p = subprocess.Popen(['git', 'rev-parse', '--show-toplevel'],

+                             cwd=distr_root,

+                             stdout=subprocess.PIPE, stderr=subprocess.PIPE)

+    except OSError:

+        return

+    if p.wait() != 0:

+        return

+    if not os.path.samefile(p.communicate()[0].decode().rstrip('\n'),

+                            distr_root):

+        # The top-level directory of the current Git repository is not the same

+        # as the root directory of the Kwant distribution: do not extract the

+        # version from Git.

+        return

+

+    # git describe --first-parent does not take into account tags from branches

+    # that were merged-in.

+    for opts in [['--first-parent'], []]:

         try:

-            dispcmd = str([c] + 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))

+            p = subprocess.Popen(['git', 'describe', '--long'] + opts,

+                                 cwd=distr_root,

+                                 stdout=subprocess.PIPE, stderr=subprocess.PIPE)

+        except OSError:

+            return

+        if p.wait() == 0:

             break

-        except EnvironmentError:

-            e = sys.exc_info()[1]

-            if e.errno == errno.ENOENT:

-                continue

-            if verbose:

-                print("unable to run %s" % dispcmd)

-                print(e)

-            return None, None

     else:

-        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:

-        if verbose:

-            print("unable to run %s (error)" % dispcmd)

-            print("stdout was %s" % stdout)

-        return None, p.returncode

-    return stdout, p.returncode

-

-

-def versions_from_parentdir(parentdir_prefix, root, verbose):

-    """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 i 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

-

-    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)

-            if line.strip().startswith("git_date ="):

-                mo = re.search(r'=\s*"(.*)"', line)

-                if mo:

-                    keywords["date"] = mo.group(1)

-        f.close()

-    except EnvironmentError:

-        pass

-    return keywords

-

-

-@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")

-    date = keywords.get("date")

-    if date is not None:

-        # 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(",")])

-    # 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)])

-    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

-        # expansion behaves like git log --decorate=short and strips out the

-        # refs/heads/ and refs/tags/ prefixes that would let us distinguish

-        # 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)])

-        if verbose:

-            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):]

-            if verbose:

-                print("picking %s" % r)

-            return {"version": r,

-                    "full-revisionid": keywords["full"].strip(),

-                    "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", "date": None}

-

-

-@register_vcs_handler("git", "pieces_from_vcs")

-def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=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"]

-    if sys.platform == "win32":

-        GITS = ["git.cmd", "git.exe"]

-

-    out, rc = run_command(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 = run_command(GITS, ["describe", "--tags", "--dirty",

-                                          "--always", "--long",

-                                          "--match", "%s*" % tag_prefix],

-                                   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)

-    if full_out is None:

-        raise NotThisMethod("'git rev-parse' failed")

-    full_out = full_out.strip()

-

-    pieces = {}

-    pieces["long"] = full_out

-    pieces["short"] = full_out[:7]  # maybe improved later

-    pieces["error"] = None

-

-    # parse describe_out. It will be like TAG-NUM-gHEX[-dirty] or HEX[-dirty]

-    # TAG might have hyphens.

-    git_describe = describe_out

-

-    # look for -dirty suffix

-    dirty = git_describe.endswith("-dirty")

-    pieces["dirty"] = dirty

-    if dirty:

-        git_describe = git_describe[:git_describe.rindex("-dirty")]

-

-    # now we have TAG-NUM-gHEX or HEX

-

-    if "-" in git_describe:

-        # TAG-NUM-gHEX

-        mo = re.search(r'^(.+)-(\d+)-g([0-9a-f]+)$', git_describe)

-        if not mo:

-            # unparseable. Maybe git-describe is misbehaving?

-            pieces["error"] = ("unable to parse git-describe output: '%s'"

-                               % describe_out)

-            return pieces

-

-        # tag

-        full_tag = mo.group(1)

-        if not full_tag.startswith(tag_prefix):

-            if verbose:

-                fmt = "tag '%s' doesn't start with prefix '%s'"

-                print(fmt % (full_tag, tag_prefix))

-            pieces["error"] = ("tag '%s' doesn't start with prefix '%s'"

-                               % (full_tag, tag_prefix))

-            return pieces

-        pieces["closest-tag"] = full_tag[len(tag_prefix):]

-

-        # distance: number of commits since tag

-        pieces["distance"] = int(mo.group(2))

-

-        # commit: short hex revision ID

-        pieces["short"] = mo.group(3)

+        return

+    description = p.communicate()[0].decode().strip('v').rstrip('\n')

+    release, dev, git = description.rsplit('-', 2)

+    labels = []

+    if dev == "0":

+        dev = None

     else:

-        # HEX: no tags

-        pieces["closest-tag"] = None

-        count_out, rc = run_command(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()

-    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):

-    """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

-

-    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"]:

-            rendered += plus_or_dot(pieces)

-            rendered += "%d.g%s" % (pieces["distance"], pieces["short"])

-            if pieces["dirty"]:

-                rendered += ".dirty"

-    else:

-        # exception #1

-        rendered = "0+untagged.%d.g%s" % (pieces["distance"],

-                                          pieces["short"])

-        if pieces["dirty"]:

-            rendered += ".dirty"

-    return rendered

-

-

-def render_pep440_pre(pieces):

-    """TAG[.post.devDISTANCE] -- No -dirty.

-

-    Exceptions:

-    1: no tags. 0.post.devDISTANCE

-    """

-    if pieces["closest-tag"]:

-        rendered = pieces["closest-tag"]

-        if pieces["distance"]:

-            rendered += ".post.dev%d" % pieces["distance"]

-    else:

-        # exception #1

-        rendered = "0.post.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]

-    """

-    if pieces["closest-tag"]:

-        rendered = pieces["closest-tag"]

-        if pieces["distance"] or pieces["dirty"]:

-            rendered += ".post%d" % pieces["distance"]

-            if pieces["dirty"]:

-                rendered += ".dev0"

-            rendered += plus_or_dot(pieces)

-            rendered += "g%s" % pieces["short"]

-    else:

-        # exception #1

-        rendered = "0.post%d" % pieces["distance"]

-        if pieces["dirty"]:

-            rendered += ".dev0"

-        rendered += "+g%s" % pieces["short"]

-    return rendered

-

-

-def render_pep440_old(pieces):

-    """TAG[.postDISTANCE[.dev0]] .

-

-    The ".dev0" means dirty.

-

-    Eexceptions:

-    1: no tags. 0.postDISTANCE[.dev0]

-    """

-    if pieces["closest-tag"]:

-        rendered = pieces["closest-tag"]

-        if pieces["distance"] or pieces["dirty"]:

-            rendered += ".post%d" % pieces["distance"]

-            if pieces["dirty"]:

-                rendered += ".dev0"

-    else:

-        # exception #1

-        rendered = "0.post%d" % pieces["distance"]

-        if pieces["dirty"]:

-            rendered += ".dev0"

-    return rendered

-

+        labels.append(git)

-def render_git_describe(pieces):

-    """TAG[-DISTANCE-gHEX][-dirty].

-

-    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"]:

-            rendered += "-%d-g%s" % (pieces["distance"], pieces["short"])

+    try:

+        p = subprocess.Popen(['git', 'diff', '--quiet'], cwd=distr_root)

+    except OSError:

+        labels.append('confused') # This should never happen.

     else:

-        # exception #1

-        rendered = pieces["short"]

-    if pieces["dirty"]:

-        rendered += "-dirty"

-    return rendered

-

+        if p.wait() == 1:

+            labels.append('dirty')

-def render_git_describe_long(pieces):

-    """TAG-DISTANCE-gHEX[-dirty].

+    return Version(release, dev, labels)

-    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"])

-    else:

-        # exception #1

-        rendered = pieces["short"]

-    if pieces["dirty"]:

-        rendered += "-dirty"

-    return rendered

-

-

-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"],

-                "date": None}

-

-    if not style or style == "default":

-        style = "pep440"  # the default

-

-    if style == "pep440":

-        rendered = render_pep440(pieces)

-    elif style == "pep440-pre":

-        rendered = render_pep440_pre(pieces)

-    elif style == "pep440-post":

-        rendered = render_pep440_post(pieces)

-    elif style == "pep440-old":

-        rendered = render_pep440_old(pieces)

-    elif style == "git-describe":

-        rendered = render_git_describe(pieces)

-    elif style == "git-describe-long":

-        rendered = render_git_describe_long(pieces)

+# TODO: change this logic when there is a git pretty-format

+#       that gives the same output as 'git describe'.

+#       Currently we can only tell the tag the current commit is

+#       pointing to, or its hash (with no version info)

+#       if it is not tagged.

+def get_version_from_git_archive(version_info):

+    try:

+        refnames = version_info['refnames']

+        git_hash = version_info['git_hash']

+    except KeyError:

+        # These fields are not present if we are running from an sdist.

+        # Execution should never reach here, though

+        return None

+

+    if git_hash.startswith('$Format') or refnames.startswith('$Format'):

+        # variables not expanded during 'git archive'

+        return None

+

+    VTAG = 'tag: v'

+    refs = set(r.strip() for r in refnames.split(","))

+    version_tags = set(r[len(VTAG):] for r in refs if r.startswith(VTAG))

+    if version_tags:

+        release, *_ = sorted(version_tags)  # prefer e.g. "2.0" over "2.0rc1"

+        return Version(release, dev=None, labels=None)

     else:

-        raise ValueError("unknown style '%s'" % style)

-

-    return {"version": rendered, "full-revisionid": pieces["long"],

-            "dirty": pieces["dirty"], "error": None,

-            "date": pieces.get("date")}

+        return Version('unknown', dev=None, labels=[f'g{git_hash}'])

-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

-    # case we can only use expanded keywords.

+__version__ = get_version()

-    cfg = get_config()

-    verbose = cfg.verbose

+# The following section defines a module global 'cmdclass',

+# which can be used from setup.py. The 'package_name' and

+# '__version__' module globals are used (but not modified).

+def _write_version(fname):

+    # This could be a hard link, so try to delete it first.  Is there any way

+    # to do this atomically together with opening?

     try:

-        return git_versions_from_keywords(get_keywords(), cfg.tag_prefix,

-                                          verbose)

-    except NotThisMethod:

+        os.remove(fname)

+    except OSError:

         pass

+    with open(fname, 'w') as f:

+        f.write("# This file has been created by setup.py.\n"

+                "version = '{}'\n".format(__version__))

-    try:

-        root = os.path.realpath(__file__)

-        # 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('/'):

-            root = os.path.dirname(root)

-    except NameError:

-        return {"version": "0+unknown", "full-revisionid": None,

-                "dirty": None,

-                "error": "unable to find root of source tree",

-                "date": None}

-    try:

-        pieces = git_pieces_from_vcs(cfg.tag_prefix, root, verbose)

-        return render(pieces, cfg.style)

-    except NotThisMethod:

-        pass

+class _build(build_orig):

+    def run(self):

+        super().run()

+        _write_version(os.path.join(self.build_lib, package_name,

+                                    STATIC_VERSION_FILE))

+

+

+class _sdist(sdist_orig):

+    def make_release_tree(self, base_dir, files):

+        super().make_release_tree(base_dir, files)

+        _write_version(os.path.join(base_dir, package_name,

+                                    STATIC_VERSION_FILE))

-    try:

-        if cfg.parentdir_prefix:

-            return versions_from_parentdir(cfg.parentdir_prefix, root, verbose)

-    except NotThisMethod:

-        pass

-    return {"version": "0+unknown", "full-revisionid": None,

-            "dirty": None,

-            "error": "unable to compute version", "date": None}

+cmdclass = dict(sdist=_sdist, build=_build)

new file mode 100644

@@ -0,0 +1,520 @@

+

+# 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

+# directories (produced by setup.py build) will contain a much shorter file

+# that just contains the computed version number.

+

+# This file is released into the public domain. Generated by

+# versioneer-0.18 (https://github.com/warner/python-versioneer)

+

+"""Git implementation of _version.py."""

+

+import errno

+import os

+import re

+import subprocess

+import sys

+

+

+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 = "$Format:%d$"

+    git_full = "$Format:%H$"

+    git_date = "$Format:%ci$"

+    keywords = {"refnames": git_refnames, "full": git_full, "date": git_date}

+    return keywords

+

+

+class VersioneerConfig:

+    """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()

+    cfg.VCS = "git"

+    cfg.style = "pep440"

+    cfg.tag_prefix = ""

+    cfg.parentdir_prefix = "nord-"

+    cfg.versionfile_source = "nord/_version.py"

+    cfg.verbose = False

+    return cfg

+

+

+class NotThisMethod(Exception):

+    """Exception raised if a method is not valid for the current scenario."""

+

+

+LONG_VERSION_PY = {}

+HANDLERS = {}

+

+

+def register_vcs_handler(vcs, method):  # decorator

+    """Decorator to mark a method as the handler for a particular VCS."""

+    def decorate(f):

+        """Store f in HANDLERS[vcs][method]."""

+        if vcs not in HANDLERS:

+            HANDLERS[vcs] = {}

+        HANDLERS[vcs][method] = f

+        return f

+    return decorate

+

+

+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:

+        try:

+            dispcmd = str([c] + 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))

+            break

+        except EnvironmentError:

+            e = sys.exc_info()[1]

+            if e.errno == errno.ENOENT:

+                continue

+            if verbose:

+                print("unable to run %s" % dispcmd)

+                print(e)

+            return None, None

+    else:

+        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:

+        if verbose:

+            print("unable to run %s (error)" % dispcmd)

+            print("stdout was %s" % stdout)

+        return None, p.returncode

+    return stdout, p.returncode

+

+

+def versions_from_parentdir(parentdir_prefix, root, verbose):

+    """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 i 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

+

+    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)

+            if line.strip().startswith("git_date ="):

+                mo = re.search(r'=\s*"(.*)"', line)

+                if mo:

+                    keywords["date"] = mo.group(1)

+        f.close()

+    except EnvironmentError:

+        pass

+    return keywords

+

+

+@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")

+    date = keywords.get("date")

+    if date is not None:

+        # 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(",")])

+    # 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)])

+    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

+        # expansion behaves like git log --decorate=short and strips out the

+        # refs/heads/ and refs/tags/ prefixes that would let us distinguish

+        # 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)])

+        if verbose:

+            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):]

+            if verbose:

+                print("picking %s" % r)

+            return {"version": r,

+                    "full-revisionid": keywords["full"].strip(),

+                    "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", "date": None}

+

+

+@register_vcs_handler("git", "pieces_from_vcs")

+def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=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"]

+    if sys.platform == "win32":