7318475939

Committed 15 Dec 2023 11:58PM UTC coverage: 84.852% (+0.3%) from 84.589%

Build # 7318475939

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #2852 from PrincetonUniversity/devel

Devel

Run Details

13470 of 16609 branches covered (0.0%)

Branch coverage included in aggregate %.

2168 of 2345 new or added lines in 47 files covered. (92.45%)

59 existing lines in 11 files now uncovered.

31551 of 36449 relevant lines covered (86.56%)

0.87 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

34.44

/psyneulink/_version.py


# 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

root_dir = os.path.abspath(os.path.dirname(__file__))

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 = "v"
    cfg.parentdir_prefix = "psyneulink-"
    cfg.versionfile_source = "psyneulink/_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":
        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)

    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


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"])
    else:
        # exception #1
        rendered = pieces["short"]
    if pieces["dirty"]:
        rendered += "-dirty"
    return rendered


def render_git_describe_long(pieces):
    """TAG-DISTANCE-gHEX[-dirty].

    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)
    else:
        raise ValueError("unknown style '%s'" % style)

    return {"version": rendered, "full-revisionid": pieces["long"],
            "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
    # case we can only use expanded keywords.

    cfg = get_config()
    verbose = cfg.verbose

    try:
        return git_versions_from_keywords(get_keywords(), cfg.tag_prefix,
                                          verbose)
    except NotThisMethod:
        pass

    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

    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}

1
2	# This file helps to compute a version number in source trees obtained from
3	# git-archive tarball (such as those provided by githubs download-from-tag
4	# feature). Distribution tarballs (built by setup.py sdist) and build
5	# directories (produced by setup.py build) will contain a much shorter file
6	# that just contains the computed version number.
7
8	# This file is released into the public domain. Generated by
9	# versioneer-0.18 (https://github.com/warner/python-versioneer)
10
11	"""Git implementation of _version.py."""	1✔
12
13	import errno	1✔
14	import os	1✔
15	import re	1✔
16	import subprocess	1✔
17	import sys	1✔
18
19	root_dir = os.path.abspath(os.path.dirname(__file__))	1✔
20
21	def get_keywords():	1✔
22	"""Get the keywords needed to look up the version information."""
23	# these strings will be replaced by git during git-archive.
24	# setup.py/versioneer.py will grep for the variable names, so they must
25	# each be defined on a line of their own. _version.py will just call
26	# get_keywords().
27	git_refnames = "$Format:%d$"	1✔
28	git_full = "$Format:%H$"	1✔
29	git_date = "$Format:%ci$"	1✔
30	keywords = {"refnames": git_refnames, "full": git_full, "date": git_date}	1✔
31	return keywords	1✔
32
33
34	class VersioneerConfig:	1✔
35	"""Container for Versioneer configuration parameters."""
36
37
38	def get_config():	1✔
39	"""Create, populate and return the VersioneerConfig() object."""
40	# these strings are filled in when 'setup.py versioneer' creates
41	# _version.py
42	cfg = VersioneerConfig()	1✔
43	cfg.VCS = "git"	1✔
44	cfg.style = "pep440"	1✔
45	cfg.tag_prefix = "v"	1✔
46	cfg.parentdir_prefix = "psyneulink-"	1✔
47	cfg.versionfile_source = "psyneulink/_version.py"	1✔
48	cfg.verbose = False	1✔
49	return cfg	1✔
50
51
52	class NotThisMethod(Exception):	1✔
53	"""Exception raised if a method is not valid for the current scenario."""
54
55
56	LONG_VERSION_PY = {}	1✔
57	HANDLERS = {}	1✔
58
59
60	def register_vcs_handler(vcs, method): # decorator	1✔
61	"""Decorator to mark a method as the handler for a particular VCS."""
62	def decorate(f):	1✔
63	"""Store f in HANDLERS[vcs][method]."""
64	if vcs not in HANDLERS:	1✔
65	HANDLERS[vcs] = {}	1✔
66	HANDLERS[vcs][method] = f	1✔
67	return f	1✔
68	return decorate	1✔
69
70
71	def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False,	1✔
72	env=None):
73	"""Call the given command(s)."""
74	assert isinstance(commands, list)	1✔
75	p = None	1✔
76	for c in commands:	1!
77	try:	1✔
78	dispcmd = str([c] + args)	1✔
79	# remember shell=False, so use git.cmd on windows, not just git
80	p = subprocess.Popen([c] + args, cwd=cwd, env=env,	1✔
81	stdout=subprocess.PIPE,
82	stderr=(subprocess.PIPE if hide_stderr
83	else None))
84	break	1✔
85	except EnvironmentError:	×
86	e = sys.exc_info()[1]	×
87	if e.errno == errno.ENOENT:	×
88	continue	×
89	if verbose:	×
90	print("unable to run %s" % dispcmd)	×
91	print(e)	×
92	return None, None	×
93	else:
94	if verbose:	×
95	print("unable to find command, tried %s" % (commands,))	×
96	return None, None	×
97	stdout = p.communicate()[0].strip()	1✔
98	if sys.version_info[0] >= 3:	1!
99	stdout = stdout.decode()	1✔
100	if p.returncode != 0:	1!
101	if verbose:	×
102	print("unable to run %s (error)" % dispcmd)	×
103	print("stdout was %s" % stdout)	×
104	return None, p.returncode	×
105	return stdout, p.returncode	1✔
106
107
108	def versions_from_parentdir(parentdir_prefix, root, verbose):	1✔
109	"""Try to determine the version from the parent directory name.
110
111	Source tarballs conventionally unpack into a directory that includes both
112	the project name and a version string. We will also support searching up
113	two directory levels for an appropriately named parent directory
114	"""
115	rootdirs = []	×
116
117	for i in range(3):	×
118	dirname = os.path.basename(root)	×
119	if dirname.startswith(parentdir_prefix):	×
120	return {"version": dirname[len(parentdir_prefix):],	×
121	"full-revisionid": None,
122	"dirty": False, "error": None, "date": None}
123	else:
124	rootdirs.append(root)	×
125	root = os.path.dirname(root) # up a level	×
126
127	if verbose:	×
128	print("Tried directories %s but none started with prefix %s" %	×
129	(str(rootdirs), parentdir_prefix))
130	raise NotThisMethod("rootdir doesn't start with parentdir_prefix")	×
131
132
133	@register_vcs_handler("git", "get_keywords")	1✔
134	def git_get_keywords(versionfile_abs):	1✔
135	"""Extract version information from the given file."""
136	# the code embedded in _version.py can just fetch the value of these
137	# keywords. When used from setup.py, we don't want to import _version.py,
138	# so we do it with a regexp instead. This function is not used from
139	# _version.py.
140	keywords = {}	×
141	try:	×
142	f = open(versionfile_abs, "r")	×
143	for line in f.readlines():	×
144	if line.strip().startswith("git_refnames ="):	×
145	mo = re.search(r'=\s"(.)"', line)	×
146	if mo:	×
147	keywords["refnames"] = mo.group(1)	×
148	if line.strip().startswith("git_full ="):	×
149	mo = re.search(r'=\s"(.)"', line)	×
150	if mo:	×
151	keywords["full"] = mo.group(1)	×
152	if line.strip().startswith("git_date ="):	×
153	mo = re.search(r'=\s"(.)"', line)	×
154	if mo:	×
155	keywords["date"] = mo.group(1)	×
156	f.close()	×
157	except EnvironmentError:	×
158	pass	×
159	return keywords	×
160
161
162	@register_vcs_handler("git", "keywords")	1✔
163	def git_versions_from_keywords(keywords, tag_prefix, verbose):	1✔
164	"""Get version information from git keywords."""
165	if not keywords:	1!
166	raise NotThisMethod("no keywords at all, weird")	×
167	date = keywords.get("date")	1✔
168	if date is not None:	1!
169	# git-2.2.0 added "%cI", which expands to an ISO-8601 -compliant
170	# datestamp. However we prefer "%ci" (which expands to an "ISO-8601
171	# -like" string, which we must then edit to make compliant), because
172	# it's been around since git-1.5.3, and it's too difficult to
173	# discover which version we're using, or to work around using an
174	# older one.
175	date = date.strip().replace(" ", "T", 1).replace(" ", "", 1)	1✔
176	refnames = keywords["refnames"].strip()	1✔
177	if refnames.startswith("$Format"):	1!
178	if verbose:	1!
179	print("keywords are unexpanded, not using")	×
180	raise NotThisMethod("unexpanded keywords, not a git-archive tarball")	1✔
181	refs = set([r.strip() for r in refnames.strip("()").split(",")])	×
182	# starting in git-1.8.3, tags are listed as "tag: foo-1.0" instead of
183	# just "foo-1.0". If we see a "tag: " prefix, prefer those.
184	TAG = "tag: "	×
185	tags = set([r[len(TAG):] for r in refs if r.startswith(TAG)])	×
186	if not tags:	×
187	# Either we're using git < 1.8.3, or there really are no tags. We use
188	# a heuristic: assume all version tags have a digit. The old git %d
189	# expansion behaves like git log --decorate=short and strips out the
190	# refs/heads/ and refs/tags/ prefixes that would let us distinguish
191	# between branches and tags. By ignoring refnames without digits, we
192	# filter out many common branch names like "release" and
193	# "stabilization", as well as "HEAD" and "master".
194	tags = set([r for r in refs if re.search(r'\d', r)])	×
195	if verbose:	×
196	print("discarding '%s', no digits" % ",".join(refs - tags))	×
197	if verbose:	×
198	print("likely tags: %s" % ",".join(sorted(tags)))	×
199	for ref in sorted(tags):	×
200	# sorting will prefer e.g. "2.0" over "2.0rc1"
201	if ref.startswith(tag_prefix):	×
202	r = ref[len(tag_prefix):]	×
203	if verbose:	×
204	print("picking %s" % r)	×
205	return {"version": r,	×
206	"full-revisionid": keywords["full"].strip(),
207	"dirty": False, "error": None,
208	"date": date}
209	# no suitable tags, so version is "0+unknown", but full hex is still there
210	if verbose:	×
211	print("no suitable tags, using unknown + full revision id")	×
212	return {"version": "0+unknown",	×
213	"full-revisionid": keywords["full"].strip(),
214	"dirty": False, "error": "no suitable tags", "date": None}
215
216
217	@register_vcs_handler("git", "pieces_from_vcs")	1✔
218	def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command):	1✔
219	"""Get version from 'git describe' in the root of the source tree.
220
221	This only gets called if the git-archive 'subst' keywords were not
222	expanded, and _version.py hasn't already been rewritten with a short
223	version string, meaning we're inside a checked out source tree.
224	"""
225	GITS = ["git"]	1✔
226	if sys.platform == "win32":	1!
227	GITS = ["git.cmd", "git.exe"]	×
228
229	out, rc = run_command(GITS, ["rev-parse", "--git-dir"], cwd=root,	1✔
230	hide_stderr=True)
231	if rc != 0:	1!
232	if verbose:	×
233	print("Directory %s not under git control" % root)	×
234	raise NotThisMethod("'git rev-parse --git-dir' returned error")	×
235
236	# if there is a tag matching tag_prefix, this yields TAG-NUM-gHEX[-dirty]
237	# if there isn't one, this yields HEX[-dirty] (no NUM)
238	describe_out, rc = run_command(GITS, ["describe", "--tags", "--dirty",	1✔
239	"--always", "--long",
240	"--match", "%s*" % tag_prefix],
241	cwd=root)
242	# --long was added in git-1.5.5
243	if describe_out is None:	1!
244	raise NotThisMethod("'git describe' failed")	×
245	describe_out = describe_out.strip()	1✔
246	full_out, rc = run_command(GITS, ["rev-parse", "HEAD"], cwd=root)	1✔
247	if full_out is None:	1!
248	raise NotThisMethod("'git rev-parse' failed")	×
249	full_out = full_out.strip()	1✔
250
251	pieces = {}	1✔
252	pieces["long"] = full_out	1✔
253	pieces["short"] = full_out[:7] # maybe improved later	1✔
254	pieces["error"] = None	1✔
255
256	# parse describe_out. It will be like TAG-NUM-gHEX[-dirty] or HEX[-dirty]
257	# TAG might have hyphens.
258	git_describe = describe_out	1✔
259
260	# look for -dirty suffix
261	dirty = git_describe.endswith("-dirty")	1✔
262	pieces["dirty"] = dirty	1✔
263	if dirty:	1!
264	git_describe = git_describe[:git_describe.rindex("-dirty")]	×
265
266	# now we have TAG-NUM-gHEX or HEX
267
268	if "-" in git_describe:	1!
269	# TAG-NUM-gHEX
270	mo = re.search(r'^(.+)-(\d+)-g([0-9a-f]+)$', git_describe)	1✔
271	if not mo:	1!
272	# unparseable. Maybe git-describe is misbehaving?
273	pieces["error"] = ("unable to parse git-describe output: '%s'"	×
274	% describe_out)
275	return pieces	×
276
277	# tag
278	full_tag = mo.group(1)	1✔
279	if not full_tag.startswith(tag_prefix):	1!
280	if verbose:	×
281	fmt = "tag '%s' doesn't start with prefix '%s'"	×
282	print(fmt % (full_tag, tag_prefix))	×
283	pieces["error"] = ("tag '%s' doesn't start with prefix '%s'"	×
284	% (full_tag, tag_prefix))
285	return pieces	×
286	pieces["closest-tag"] = full_tag[len(tag_prefix):]	1✔
287
288	# distance: number of commits since tag
289	pieces["distance"] = int(mo.group(2))	1✔
290
291	# commit: short hex revision ID
292	pieces["short"] = mo.group(3)	1✔
293
294	else:
295	# HEX: no tags
296	pieces["closest-tag"] = None	×
297	count_out, rc = run_command(GITS, ["rev-list", "HEAD", "--count"],	×
298	cwd=root)
299	pieces["distance"] = int(count_out) # total number of commits	×
300
301	# commit date: see ISO-8601 comment in git_versions_from_keywords()
302	date = run_command(GITS, ["show", "-s", "--format=%ci", "HEAD"],	1✔
303	cwd=root)[0].strip()
304	pieces["date"] = date.strip().replace(" ", "T", 1).replace(" ", "", 1)	1✔
305
306	return pieces	1✔
307
308
309	def plus_or_dot(pieces):	1✔
310	"""Return a + if we don't already have one, else return a ."""
UNCOV 311	if "+" in pieces.get("closest-tag", ""):	×
312	return "."	×
UNCOV 313	return "+"	×
314
315
316	def render_pep440(pieces):	1✔
317	"""Build up version string, with post-release "local version identifier".
318
319	Our goal: TAG[+DISTANCE.gHEX[.dirty]] . Note that if you
320	get a tagged build and then dirty it, you'll get TAG+0.gHEX.dirty
321
322	Exceptions:
323	1: no tags. git_describe was just HEX. 0+untagged.DISTANCE.gHEX[.dirty]
324	"""
325	if pieces["closest-tag"]:	1!
326	rendered = pieces["closest-tag"]	1✔
327	if pieces["distance"] or pieces["dirty"]:	1!
UNCOV 328	rendered += plus_or_dot(pieces)	×
UNCOV 329	rendered += "%d.g%s" % (pieces["distance"], pieces["short"])	×
UNCOV 330	if pieces["dirty"]:	×
331	rendered += ".dirty"	×
332	else:
333	# exception #1
334	rendered = "0+untagged.%d.g%s" % (pieces["distance"],	×
335	pieces["short"])
336	if pieces["dirty"]:	×
337	rendered += ".dirty"	×
338	return rendered	1✔
339
340
341	def render_pep440_pre(pieces):	1✔
342	"""TAG[.post.devDISTANCE] -- No -dirty.
343
344	Exceptions:
345	1: no tags. 0.post.devDISTANCE
346	"""
347	if pieces["closest-tag"]:	×
348	rendered = pieces["closest-tag"]	×
349	if pieces["distance"]:	×
350	rendered += ".post.dev%d" % pieces["distance"]	×
351	else:
352	# exception #1
353	rendered = "0.post.dev%d" % pieces["distance"]	×
354	return rendered	×
355
356
357	def render_pep440_post(pieces):	1✔
358	"""TAG[.postDISTANCE[.dev0]+gHEX] .
359
360	The ".dev0" means dirty. Note that .dev0 sorts backwards
361	(a dirty tree will appear "older" than the corresponding clean one),
362	but you shouldn't be releasing software with -dirty anyways.
363
364	Exceptions:
365	1: no tags. 0.postDISTANCE[.dev0]
366	"""
367	if pieces["closest-tag"]:	×
368	rendered = pieces["closest-tag"]	×
369	if pieces["distance"] or pieces["dirty"]:	×
370	rendered += ".post%d" % pieces["distance"]	×
371	if pieces["dirty"]:	×
372	rendered += ".dev0"	×
373	rendered += plus_or_dot(pieces)	×
374	rendered += "g%s" % pieces["short"]	×
375	else:
376	# exception #1
377	rendered = "0.post%d" % pieces["distance"]	×
378	if pieces["dirty"]:	×
379	rendered += ".dev0"	×
380	rendered += "+g%s" % pieces["short"]	×
381	return rendered	×
382
383
384	def render_pep440_old(pieces):	1✔
385	"""TAG[.postDISTANCE[.dev0]] .
386
387	The ".dev0" means dirty.
388
389	Eexceptions:
390	1: no tags. 0.postDISTANCE[.dev0]
391	"""
392	if pieces["closest-tag"]:	×
393	rendered = pieces["closest-tag"]	×
394	if pieces["distance"] or pieces["dirty"]:	×
395	rendered += ".post%d" % pieces["distance"]	×
396	if pieces["dirty"]:	×
397	rendered += ".dev0"	×
398	else:
399	# exception #1
400	rendered = "0.post%d" % pieces["distance"]	×
401	if pieces["dirty"]:	×
402	rendered += ".dev0"	×
403	return rendered	×
404
405
406	def render_git_describe(pieces):	1✔
407	"""TAG[-DISTANCE-gHEX][-dirty].
408
409	Like 'git describe --tags --dirty --always'.
410
411	Exceptions:
412	1: no tags. HEX[-dirty] (note: no 'g' prefix)
413	"""
414	if pieces["closest-tag"]:	×
415	rendered = pieces["closest-tag"]	×
416	if pieces["distance"]:	×
417	rendered += "-%d-g%s" % (pieces["distance"], pieces["short"])	×
418	else:
419	# exception #1
420	rendered = pieces["short"]	×
421	if pieces["dirty"]:	×
422	rendered += "-dirty"	×
423	return rendered	×
424
425
426	def render_git_describe_long(pieces):	1✔
427	"""TAG-DISTANCE-gHEX[-dirty].
428
429	Like 'git describe --tags --dirty --always -long'.
430	The distance/hash is unconditional.
431
432	Exceptions:
433	1: no tags. HEX[-dirty] (note: no 'g' prefix)
434	"""
435	if pieces["closest-tag"]:	×
436	rendered = pieces["closest-tag"]	×
437	rendered += "-%d-g%s" % (pieces["distance"], pieces["short"])	×
438	else:
439	# exception #1
440	rendered = pieces["short"]	×
441	if pieces["dirty"]:	×
442	rendered += "-dirty"	×
443	return rendered	×
444
445
446	def render(pieces, style):	1✔
447	"""Render the given version pieces into the requested style."""
448	if pieces["error"]:	1!
449	return {"version": "unknown",	×
450	"full-revisionid": pieces.get("long"),
451	"dirty": None,
452	"error": pieces["error"],
453	"date": None}
454
455	if not style or style == "default":	1!
456	style = "pep440" # the default	×
457
458	if style == "pep440":	1!
459	rendered = render_pep440(pieces)	1✔
460	elif style == "pep440-pre":	×
461	rendered = render_pep440_pre(pieces)	×
462	elif style == "pep440-post":	×
463	rendered = render_pep440_post(pieces)	×
464	elif style == "pep440-old":	×
465	rendered = render_pep440_old(pieces)	×
466	elif style == "git-describe":	×
467	rendered = render_git_describe(pieces)	×
468	elif style == "git-describe-long":	×
469	rendered = render_git_describe_long(pieces)	×
470	else:
471	raise ValueError("unknown style '%s'" % style)
472
473	return {"version": rendered, "full-revisionid": pieces["long"],	1✔
474	"dirty": pieces["dirty"], "error": None,
475	"date": pieces.get("date")}
476
477
478	def get_versions():	1✔
479	"""Get version information or return default if unable to do so."""
480	# I am in _version.py, which lives at ROOT/VERSIONFILE_SOURCE. If we have
481	# __file__, we can work backwards from there to the root. Some
482	# py2exe/bbfreeze/non-CPython implementations don't do __file__, in which
483	# case we can only use expanded keywords.
484
485	cfg = get_config()	1✔
486	verbose = cfg.verbose	1✔
487
488	try:	1✔
489	return git_versions_from_keywords(get_keywords(), cfg.tag_prefix,	1✔
490	verbose)
491	except NotThisMethod:	1✔
492	pass	1✔
493
494	try:	1✔
495	root = os.path.realpath(__file__)	1✔
496	# versionfile_source is the relative path from the top of the source
497	# tree (where the .git directory might live) to this file. Invert
498	# this to find the root from __file__.
499	for i in cfg.versionfile_source.split('/'):	1✔
500	root = os.path.dirname(root)	1✔
501	except NameError:	×
502	return {"version": "0+unknown", "full-revisionid": None,	×
503	"dirty": None,
504	"error": "unable to find root of source tree",
505	"date": None}
506
507	try:	1✔
508	pieces = git_pieces_from_vcs(cfg.tag_prefix, root, verbose)	1✔
509	return render(pieces, cfg.style)	1✔
510	except NotThisMethod:	×
511	pass	×
512
513	try:	×
514	if cfg.parentdir_prefix:	×
515	return versions_from_parentdir(cfg.parentdir_prefix, root, verbose)	×
516	except NotThisMethod:	×
517	pass	×
518
519	return {"version": "0+unknown", "full-revisionid": None,	×
520	"dirty": None,
521	"error": "unable to compute version", "date": None}

PrincetonUniversity / PsyNeuLink / 7318475939

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous