|
|
|
@@ -1,197 +1,520 @@ |
|
|
|
|
|
|
|
IN_LONG_VERSION_PY = True |
|
|
|
# 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 (build by setup.py sdist) and build |
|
|
|
# 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.7+ (https://github.com/warner/python-versioneer) |
|
|
|
|
|
|
|
# these strings will be replaced by git during git-archive |
|
|
|
git_refnames = "$Format:%d$" |
|
|
|
git_full = "$Format:%H$" |
|
|
|
# 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 run_command(args, cwd=None, verbose=False): |
|
|
|
try: |
|
|
|
# remember shell=False, so use git.cmd on windows, not just git |
|
|
|
p = subprocess.Popen(args, stdout=subprocess.PIPE, cwd=cwd) |
|
|
|
except EnvironmentError: |
|
|
|
e = sys.exc_info()[1] |
|
|
|
|
|
|
|
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 = "nilmdb-" |
|
|
|
cfg.parentdir_prefix = "nilmdb-" |
|
|
|
cfg.versionfile_source = "nilmdb/_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 run %s" % args[0]) |
|
|
|
print(e) |
|
|
|
return None |
|
|
|
print(("unable to find command, tried %s" % (commands,))) |
|
|
|
return None, None |
|
|
|
stdout = p.communicate()[0].strip() |
|
|
|
if sys.version >= '3': |
|
|
|
if sys.version_info[0] >= 3: |
|
|
|
stdout = stdout.decode() |
|
|
|
if p.returncode != 0: |
|
|
|
if verbose: |
|
|
|
print("unable to run %s (error)" % args[0]) |
|
|
|
return None |
|
|
|
return stdout |
|
|
|
print(("unable to run %s (error)" % dispcmd)) |
|
|
|
print(("stdout was %s" % stdout)) |
|
|
|
return None, p.returncode |
|
|
|
return stdout, p.returncode |
|
|
|
|
|
|
|
|
|
|
|
import sys |
|
|
|
import re |
|
|
|
import os.path |
|
|
|
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") |
|
|
|
|
|
|
|
|
|
|
|
def get_expanded_variables(versionfile_source): |
|
|
|
@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 |
|
|
|
# variables. 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. |
|
|
|
variables = {} |
|
|
|
# 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: |
|
|
|
for line in open(versionfile_source,"r").readlines(): |
|
|
|
f = open(versionfile_abs, "r") |
|
|
|
for line in f.readlines(): |
|
|
|
if line.strip().startswith("git_refnames ="): |
|
|
|
mo = re.search(r'=\s*"(.*)"', line) |
|
|
|
if mo: |
|
|
|
variables["refnames"] = mo.group(1) |
|
|
|
keywords["refnames"] = mo.group(1) |
|
|
|
if line.strip().startswith("git_full ="): |
|
|
|
mo = re.search(r'=\s*"(.*)"', line) |
|
|
|
if mo: |
|
|
|
variables["full"] = mo.group(1) |
|
|
|
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 variables |
|
|
|
return keywords |
|
|
|
|
|
|
|
def versions_from_expanded_variables(variables, tag_prefix, verbose=False): |
|
|
|
refnames = variables["refnames"].strip() |
|
|
|
|
|
|
|
@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("variables are unexpanded, not using") |
|
|
|
return {} # unexpanded, so not in an unpacked git-archive tarball |
|
|
|
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(",")]) |
|
|
|
for ref in list(refs): |
|
|
|
if not re.search(r'\d', ref): |
|
|
|
if verbose: |
|
|
|
print("discarding '%s', no digits" % ref) |
|
|
|
refs.discard(ref) |
|
|
|
# Assume all version tags have a digit. git's %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". |
|
|
|
# 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("remaining refs: %s" % ",".join(sorted(refs))) |
|
|
|
for ref in sorted(refs): |
|
|
|
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": variables["full"].strip() } |
|
|
|
# no suitable tags, so we use the full revision id |
|
|
|
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 full revision id") |
|
|
|
return { "version": variables["full"].strip(), |
|
|
|
"full": variables["full"].strip() } |
|
|
|
|
|
|
|
def versions_from_vcs(tag_prefix, versionfile_source, verbose=False): |
|
|
|
# this runs 'git' from the root of the source tree. That either means |
|
|
|
# someone ran a setup.py command (and this code is in versioneer.py, so |
|
|
|
# IN_LONG_VERSION_PY=False, thus the containing directory is the root of |
|
|
|
# the source tree), or someone ran a project-specific entry point (and |
|
|
|
# this code is in _version.py, so IN_LONG_VERSION_PY=True, thus the |
|
|
|
# containing directory is somewhere deeper in the source tree). This only |
|
|
|
# gets called if the git-archive 'subst' variables 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. |
|
|
|
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} |
|
|
|
|
|
|
|
try: |
|
|
|
here = os.path.abspath(__file__) |
|
|
|
except NameError: |
|
|
|
# some py2exe/bbfreeze/non-CPython implementations don't do __file__ |
|
|
|
return {} # not always correct |
|
|
|
|
|
|
|
# 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__. |
|
|
|
root = here |
|
|
|
if IN_LONG_VERSION_PY: |
|
|
|
for i in range(len(versionfile_source.split("/"))): |
|
|
|
root = os.path.dirname(root) |
|
|
|
else: |
|
|
|
root = os.path.dirname(here) |
|
|
|
if not os.path.exists(os.path.join(root, ".git")): |
|
|
|
if verbose: |
|
|
|
print("no .git in %s" % root) |
|
|
|
return {} |
|
|
|
|
|
|
|
GIT = "git" |
|
|
|
@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": |
|
|
|
GIT = "git.cmd" |
|
|
|
stdout = run_command([GIT, "describe", "--tags", "--dirty", "--always"], |
|
|
|
cwd=root) |
|
|
|
if stdout is None: |
|
|
|
return {} |
|
|
|
if not stdout.startswith(tag_prefix): |
|
|
|
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("tag '%s' doesn't start with prefix '%s'" % (stdout, tag_prefix)) |
|
|
|
return {} |
|
|
|
tag = stdout[len(tag_prefix):] |
|
|
|
stdout = run_command([GIT, "rev-parse", "HEAD"], cwd=root) |
|
|
|
if stdout is None: |
|
|
|
return {} |
|
|
|
full = stdout.strip() |
|
|
|
if tag.endswith("-dirty"): |
|
|
|
full += "-dirty" |
|
|
|
return {"version": tag, "full": full} |
|
|
|
|
|
|
|
|
|
|
|
def versions_from_parentdir(parentdir_prefix, versionfile_source, verbose=False): |
|
|
|
if IN_LONG_VERSION_PY: |
|
|
|
# We're running from _version.py. If it's from a source tree |
|
|
|
# (execute-in-place), we can work upwards to find the root of the |
|
|
|
# tree, and then check the parent directory for a version string. If |
|
|
|
# it's in an installed application, there's no hope. |
|
|
|
try: |
|
|
|
here = os.path.abspath(__file__) |
|
|
|
except NameError: |
|
|
|
# py2exe/bbfreeze/non-CPython don't have __file__ |
|
|
|
return {} # without __file__, we have no hope |
|
|
|
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 to _version.py. Invert this to find the root from __file__. |
|
|
|
root = here |
|
|
|
for i in range(len(versionfile_source.split("/"))): |
|
|
|
# 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) |
|
|
|
else: |
|
|
|
# we're running from versioneer.py, which means we're running from |
|
|
|
# the setup.py in a source tree. sys.argv[0] is setup.py in the root. |
|
|
|
here = os.path.abspath(sys.argv[0]) |
|
|
|
root = os.path.dirname(here) |
|
|
|
|
|
|
|
# Source tarballs conventionally unpack into a directory that includes |
|
|
|
# both the project name and a version string. |
|
|
|
dirname = os.path.basename(root) |
|
|
|
if not dirname.startswith(parentdir_prefix): |
|
|
|
if verbose: |
|
|
|
print("guessing rootdir is '%s', but '%s' doesn't start with prefix '%s'" % |
|
|
|
(root, dirname, parentdir_prefix)) |
|
|
|
return None |
|
|
|
return {"version": dirname[len(parentdir_prefix):], "full": ""} |
|
|
|
|
|
|
|
tag_prefix = "nilmtools-" |
|
|
|
parentdir_prefix = "nilmtools-" |
|
|
|
versionfile_source = "nilmtools/_version.py" |
|
|
|
|
|
|
|
def get_versions(default={"version": "unknown", "full": ""}, verbose=False): |
|
|
|
variables = { "refnames": git_refnames, "full": git_full } |
|
|
|
ver = versions_from_expanded_variables(variables, tag_prefix, verbose) |
|
|
|
if not ver: |
|
|
|
ver = versions_from_vcs(tag_prefix, versionfile_source, verbose) |
|
|
|
if not ver: |
|
|
|
ver = versions_from_parentdir(parentdir_prefix, versionfile_source, |
|
|
|
verbose) |
|
|
|
if not ver: |
|
|
|
ver = default |
|
|
|
return ver |
|
|
|
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} |
