|
|
|
@@ -0,0 +1,655 @@ |
|
|
|
#! /usr/bin/python |
|
|
|
|
|
|
|
"""versioneer.py |
|
|
|
|
|
|
|
(like a rocketeer, but for versions) |
|
|
|
|
|
|
|
* https://github.com/warner/python-versioneer |
|
|
|
* Brian Warner |
|
|
|
* License: Public Domain |
|
|
|
* Version: 0.7+ |
|
|
|
|
|
|
|
This file helps distutils-based projects manage their version number by just |
|
|
|
creating version-control tags. |
|
|
|
|
|
|
|
For developers who work from a VCS-generated tree (e.g. 'git clone' etc), |
|
|
|
each 'setup.py version', 'setup.py build', 'setup.py sdist' will compute a |
|
|
|
version number by asking your version-control tool about the current |
|
|
|
checkout. The version number will be written into a generated _version.py |
|
|
|
file of your choosing, where it can be included by your __init__.py |
|
|
|
|
|
|
|
For users who work from a VCS-generated tarball (e.g. 'git archive'), it will |
|
|
|
compute a version number by looking at the name of the directory created when |
|
|
|
te tarball is unpacked. This conventionally includes both the name of the |
|
|
|
project and a version number. |
|
|
|
|
|
|
|
For users who work from a tarball built by 'setup.py sdist', it will get a |
|
|
|
version number from a previously-generated _version.py file. |
|
|
|
|
|
|
|
As a result, loading code directly from the source tree will not result in a |
|
|
|
real version. If you want real versions from VCS trees (where you frequently |
|
|
|
update from the upstream repository, or do new development), you will need to |
|
|
|
do a 'setup.py version' after each update, and load code from the build/ |
|
|
|
directory. |
|
|
|
|
|
|
|
You need to provide this code with a few configuration values: |
|
|
|
|
|
|
|
versionfile_source: |
|
|
|
A project-relative pathname into which the generated version strings |
|
|
|
should be written. This is usually a _version.py next to your project's |
|
|
|
main __init__.py file. If your project uses src/myproject/__init__.py, |
|
|
|
this should be 'src/myproject/_version.py'. This file should be checked |
|
|
|
in to your VCS as usual: the copy created below by 'setup.py |
|
|
|
update_files' will include code that parses expanded VCS keywords in |
|
|
|
generated tarballs. The 'build' and 'sdist' commands will replace it with |
|
|
|
a copy that has just the calculated version string. |
|
|
|
|
|
|
|
versionfile_build: |
|
|
|
Like versionfile_source, but relative to the build directory instead of |
|
|
|
the source directory. These will differ when your setup.py uses |
|
|
|
'package_dir='. If you have package_dir={'myproject': 'src/myproject'}, |
|
|
|
then you will probably have versionfile_build='myproject/_version.py' and |
|
|
|
versionfile_source='src/myproject/_version.py'. |
|
|
|
|
|
|
|
tag_prefix: a string, like 'PROJECTNAME-', which appears at the start of all |
|
|
|
VCS tags. If your tags look like 'myproject-1.2.0', then you |
|
|
|
should use tag_prefix='myproject-'. If you use unprefixed tags |
|
|
|
like '1.2.0', this should be an empty string. |
|
|
|
|
|
|
|
parentdir_prefix: a string, frequently the same as tag_prefix, which |
|
|
|
appears at the start of all unpacked tarball filenames. If |
|
|
|
your tarball unpacks into 'myproject-1.2.0', this should |
|
|
|
be 'myproject-'. |
|
|
|
|
|
|
|
To use it: |
|
|
|
|
|
|
|
1: include this file in the top level of your project |
|
|
|
2: make the following changes to the top of your setup.py: |
|
|
|
import versioneer |
|
|
|
versioneer.versionfile_source = 'src/myproject/_version.py' |
|
|
|
versioneer.versionfile_build = 'myproject/_version.py' |
|
|
|
versioneer.tag_prefix = '' # tags are like 1.2.0 |
|
|
|
versioneer.parentdir_prefix = 'myproject-' # dirname like 'myproject-1.2.0' |
|
|
|
3: add the following arguments to the setup() call in your setup.py: |
|
|
|
version=versioneer.get_version(), |
|
|
|
cmdclass=versioneer.get_cmdclass(), |
|
|
|
4: run 'setup.py update_files', which will create _version.py, and will |
|
|
|
append the following to your __init__.py: |
|
|
|
from _version import __version__ |
|
|
|
5: modify your MANIFEST.in to include versioneer.py |
|
|
|
6: add both versioneer.py and the generated _version.py to your VCS |
|
|
|
""" |
|
|
|
|
|
|
|
import os, sys, re |
|
|
|
from distutils.core import Command |
|
|
|
from distutils.command.sdist import sdist as _sdist |
|
|
|
from distutils.command.build_py import build_py as _build_py |
|
|
|
|
|
|
|
versionfile_source = None |
|
|
|
versionfile_build = None |
|
|
|
tag_prefix = None |
|
|
|
parentdir_prefix = None |
|
|
|
|
|
|
|
VCS = "git" |
|
|
|
IN_LONG_VERSION_PY = False |
|
|
|
|
|
|
|
|
|
|
|
LONG_VERSION_PY = ''' |
|
|
|
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 |
|
|
|
# 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 = "%(DOLLAR)sFormat:%%d%(DOLLAR)s" |
|
|
|
git_full = "%(DOLLAR)sFormat:%%H%(DOLLAR)s" |
|
|
|
|
|
|
|
|
|
|
|
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] |
|
|
|
if verbose: |
|
|
|
print("unable to run %%s" %% args[0]) |
|
|
|
print(e) |
|
|
|
return None |
|
|
|
stdout = p.communicate()[0].strip() |
|
|
|
if sys.version >= '3': |
|
|
|
stdout = stdout.decode() |
|
|
|
if p.returncode != 0: |
|
|
|
if verbose: |
|
|
|
print("unable to run %%s (error)" %% args[0]) |
|
|
|
return None |
|
|
|
return stdout |
|
|
|
|
|
|
|
|
|
|
|
import sys |
|
|
|
import re |
|
|
|
import os.path |
|
|
|
|
|
|
|
def get_expanded_variables(versionfile_source): |
|
|
|
# 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 = {} |
|
|
|
try: |
|
|
|
for line in open(versionfile_source,"r").readlines(): |
|
|
|
if line.strip().startswith("git_refnames ="): |
|
|
|
mo = re.search(r'=\s*"(.*)"', line) |
|
|
|
if mo: |
|
|
|
variables["refnames"] = mo.group(1) |
|
|
|
if line.strip().startswith("git_full ="): |
|
|
|
mo = re.search(r'=\s*"(.*)"', line) |
|
|
|
if mo: |
|
|
|
variables["full"] = mo.group(1) |
|
|
|
except EnvironmentError: |
|
|
|
pass |
|
|
|
return variables |
|
|
|
|
|
|
|
def versions_from_expanded_variables(variables, tag_prefix, verbose=False): |
|
|
|
refnames = variables["refnames"].strip() |
|
|
|
if refnames.startswith("$Format"): |
|
|
|
if verbose: |
|
|
|
print("variables are unexpanded, not using") |
|
|
|
return {} # unexpanded, so not in an unpacked 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". |
|
|
|
if verbose: |
|
|
|
print("remaining refs: %%s" %% ",".join(sorted(refs))) |
|
|
|
for ref in sorted(refs): |
|
|
|
# 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 |
|
|
|
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. |
|
|
|
|
|
|
|
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" |
|
|
|
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): |
|
|
|
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 |
|
|
|
# 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("/"))): |
|
|
|
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 = "%(TAG_PREFIX)s" |
|
|
|
parentdir_prefix = "%(PARENTDIR_PREFIX)s" |
|
|
|
versionfile_source = "%(VERSIONFILE_SOURCE)s" |
|
|
|
|
|
|
|
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 |
|
|
|
|
|
|
|
''' |
|
|
|
|
|
|
|
|
|
|
|
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] |
|
|
|
if verbose: |
|
|
|
print("unable to run %s" % args[0]) |
|
|
|
print(e) |
|
|
|
return None |
|
|
|
stdout = p.communicate()[0].strip() |
|
|
|
if sys.version >= '3': |
|
|
|
stdout = stdout.decode() |
|
|
|
if p.returncode != 0: |
|
|
|
if verbose: |
|
|
|
print("unable to run %s (error)" % args[0]) |
|
|
|
return None |
|
|
|
return stdout |
|
|
|
|
|
|
|
|
|
|
|
import sys |
|
|
|
import re |
|
|
|
import os.path |
|
|
|
|
|
|
|
def get_expanded_variables(versionfile_source): |
|
|
|
# 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 = {} |
|
|
|
try: |
|
|
|
for line in open(versionfile_source,"r").readlines(): |
|
|
|
if line.strip().startswith("git_refnames ="): |
|
|
|
mo = re.search(r'=\s*"(.*)"', line) |
|
|
|
if mo: |
|
|
|
variables["refnames"] = mo.group(1) |
|
|
|
if line.strip().startswith("git_full ="): |
|
|
|
mo = re.search(r'=\s*"(.*)"', line) |
|
|
|
if mo: |
|
|
|
variables["full"] = mo.group(1) |
|
|
|
except EnvironmentError: |
|
|
|
pass |
|
|
|
return variables |
|
|
|
|
|
|
|
def versions_from_expanded_variables(variables, tag_prefix, verbose=False): |
|
|
|
refnames = variables["refnames"].strip() |
|
|
|
if refnames.startswith("$Format"): |
|
|
|
if verbose: |
|
|
|
print("variables are unexpanded, not using") |
|
|
|
return {} # unexpanded, so not in an unpacked 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". |
|
|
|
if verbose: |
|
|
|
print("remaining refs: %s" % ",".join(sorted(refs))) |
|
|
|
for ref in sorted(refs): |
|
|
|
# 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 |
|
|
|
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. |
|
|
|
|
|
|
|
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" |
|
|
|
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): |
|
|
|
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 |
|
|
|
# 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("/"))): |
|
|
|
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": ""} |
|
|
|
|
|
|
|
import sys |
|
|
|
|
|
|
|
def do_vcs_install(versionfile_source, ipy): |
|
|
|
GIT = "git" |
|
|
|
if sys.platform == "win32": |
|
|
|
GIT = "git.cmd" |
|
|
|
run_command([GIT, "add", "versioneer.py"]) |
|
|
|
run_command([GIT, "add", versionfile_source]) |
|
|
|
run_command([GIT, "add", ipy]) |
|
|
|
present = False |
|
|
|
try: |
|
|
|
f = open(".gitattributes", "r") |
|
|
|
for line in f.readlines(): |
|
|
|
if line.strip().startswith(versionfile_source): |
|
|
|
if "export-subst" in line.strip().split()[1:]: |
|
|
|
present = True |
|
|
|
f.close() |
|
|
|
except EnvironmentError: |
|
|
|
pass |
|
|
|
if not present: |
|
|
|
f = open(".gitattributes", "a+") |
|
|
|
f.write("%s export-subst\n" % versionfile_source) |
|
|
|
f.close() |
|
|
|
run_command([GIT, "add", ".gitattributes"]) |
|
|
|
|
|
|
|
|
|
|
|
SHORT_VERSION_PY = """ |
|
|
|
# This file was generated by 'versioneer.py' (0.7+) from |
|
|
|
# revision-control system data, or from the parent directory name of an |
|
|
|
# unpacked source archive. Distribution tarballs contain a pre-generated copy |
|
|
|
# of this file. |
|
|
|
|
|
|
|
version_version = '%(version)s' |
|
|
|
version_full = '%(full)s' |
|
|
|
def get_versions(default={}, verbose=False): |
|
|
|
return {'version': version_version, 'full': version_full} |
|
|
|
|
|
|
|
""" |
|
|
|
|
|
|
|
DEFAULT = {"version": "unknown", "full": "unknown"} |
|
|
|
|
|
|
|
def versions_from_file(filename): |
|
|
|
versions = {} |
|
|
|
try: |
|
|
|
f = open(filename) |
|
|
|
except EnvironmentError: |
|
|
|
return versions |
|
|
|
for line in f.readlines(): |
|
|
|
mo = re.match("version_version = '([^']+)'", line) |
|
|
|
if mo: |
|
|
|
versions["version"] = mo.group(1) |
|
|
|
mo = re.match("version_full = '([^']+)'", line) |
|
|
|
if mo: |
|
|
|
versions["full"] = mo.group(1) |
|
|
|
return versions |
|
|
|
|
|
|
|
def write_to_version_file(filename, versions): |
|
|
|
f = open(filename, "w") |
|
|
|
f.write(SHORT_VERSION_PY % versions) |
|
|
|
f.close() |
|
|
|
print("set %s to '%s'" % (filename, versions["version"])) |
|
|
|
|
|
|
|
|
|
|
|
def get_best_versions(versionfile, tag_prefix, parentdir_prefix, |
|
|
|
default=DEFAULT, verbose=False): |
|
|
|
# returns dict with two keys: 'version' and 'full' |
|
|
|
# |
|
|
|
# extract version from first of _version.py, 'git describe', parentdir. |
|
|
|
# This is meant to work for developers using a source checkout, for users |
|
|
|
# of a tarball created by 'setup.py sdist', and for users of a |
|
|
|
# tarball/zipball created by 'git archive' or github's download-from-tag |
|
|
|
# feature. |
|
|
|
|
|
|
|
variables = get_expanded_variables(versionfile_source) |
|
|
|
if variables: |
|
|
|
ver = versions_from_expanded_variables(variables, tag_prefix) |
|
|
|
if ver: |
|
|
|
if verbose: print("got version from expanded variable %s" % ver) |
|
|
|
return ver |
|
|
|
|
|
|
|
ver = versions_from_file(versionfile) |
|
|
|
if ver: |
|
|
|
if verbose: print("got version from file %s %s" % (versionfile, ver)) |
|
|
|
return ver |
|
|
|
|
|
|
|
ver = versions_from_vcs(tag_prefix, versionfile_source, verbose) |
|
|
|
if ver: |
|
|
|
if verbose: print("got version from git %s" % ver) |
|
|
|
return ver |
|
|
|
|
|
|
|
ver = versions_from_parentdir(parentdir_prefix, versionfile_source, verbose) |
|
|
|
if ver: |
|
|
|
if verbose: print("got version from parentdir %s" % ver) |
|
|
|
return ver |
|
|
|
|
|
|
|
if verbose: print("got version from default %s" % ver) |
|
|
|
return default |
|
|
|
|
|
|
|
def get_versions(default=DEFAULT, verbose=False): |
|
|
|
assert versionfile_source is not None, "please set versioneer.versionfile_source" |
|
|
|
assert tag_prefix is not None, "please set versioneer.tag_prefix" |
|
|
|
assert parentdir_prefix is not None, "please set versioneer.parentdir_prefix" |
|
|
|
return get_best_versions(versionfile_source, tag_prefix, parentdir_prefix, |
|
|
|
default=default, verbose=verbose) |
|
|
|
def get_version(verbose=False): |
|
|
|
return get_versions(verbose=verbose)["version"] |
|
|
|
|
|
|
|
class cmd_version(Command): |
|
|
|
description = "report generated version string" |
|
|
|
user_options = [] |
|
|
|
boolean_options = [] |
|
|
|
def initialize_options(self): |
|
|
|
pass |
|
|
|
def finalize_options(self): |
|
|
|
pass |
|
|
|
def run(self): |
|
|
|
ver = get_version(verbose=True) |
|
|
|
print("Version is currently: %s" % ver) |
|
|
|
|
|
|
|
class cmd_build_py(_build_py): |
|
|
|
def run(self): |
|
|
|
versions = get_versions(verbose=True) |
|
|
|
_build_py.run(self) |
|
|
|
# now locate _version.py in the new build/ directory and replace it |
|
|
|
# with an updated value |
|
|
|
target_versionfile = os.path.join(self.build_lib, versionfile_build) |
|
|
|
print("UPDATING %s" % target_versionfile) |
|
|
|
os.unlink(target_versionfile) |
|
|
|
f = open(target_versionfile, "w") |
|
|
|
f.write(SHORT_VERSION_PY % versions) |
|
|
|
f.close() |
|
|
|
|
|
|
|
class cmd_sdist(_sdist): |
|
|
|
def run(self): |
|
|
|
versions = get_versions(verbose=True) |
|
|
|
self._versioneer_generated_versions = versions |
|
|
|
# unless we update this, the command will keep using the old version |
|
|
|
self.distribution.metadata.version = versions["version"] |
|
|
|
return _sdist.run(self) |
|
|
|
|
|
|
|
def make_release_tree(self, base_dir, files): |
|
|
|
_sdist.make_release_tree(self, base_dir, files) |
|
|
|
# now locate _version.py in the new base_dir directory (remembering |
|
|
|
# that it may be a hardlink) and replace it with an updated value |
|
|
|
target_versionfile = os.path.join(base_dir, versionfile_source) |
|
|
|
print("UPDATING %s" % target_versionfile) |
|
|
|
os.unlink(target_versionfile) |
|
|
|
f = open(target_versionfile, "w") |
|
|
|
f.write(SHORT_VERSION_PY % self._versioneer_generated_versions) |
|
|
|
f.close() |
|
|
|
|
|
|
|
INIT_PY_SNIPPET = """ |
|
|
|
from ._version import get_versions |
|
|
|
__version__ = get_versions()['version'] |
|
|
|
del get_versions |
|
|
|
""" |
|
|
|
|
|
|
|
class cmd_update_files(Command): |
|
|
|
description = "modify __init__.py and create _version.py" |
|
|
|
user_options = [] |
|
|
|
boolean_options = [] |
|
|
|
def initialize_options(self): |
|
|
|
pass |
|
|
|
def finalize_options(self): |
|
|
|
pass |
|
|
|
def run(self): |
|
|
|
ipy = os.path.join(os.path.dirname(versionfile_source), "__init__.py") |
|
|
|
print(" creating %s" % versionfile_source) |
|
|
|
f = open(versionfile_source, "w") |
|
|
|
f.write(LONG_VERSION_PY % {"DOLLAR": "$", |
|
|
|
"TAG_PREFIX": tag_prefix, |
|
|
|
"PARENTDIR_PREFIX": parentdir_prefix, |
|
|
|
"VERSIONFILE_SOURCE": versionfile_source, |
|
|
|
}) |
|
|
|
f.close() |
|
|
|
try: |
|
|
|
old = open(ipy, "r").read() |
|
|
|
except EnvironmentError: |
|
|
|
old = "" |
|
|
|
if INIT_PY_SNIPPET not in old: |
|
|
|
print(" appending to %s" % ipy) |
|
|
|
f = open(ipy, "a") |
|
|
|
f.write(INIT_PY_SNIPPET) |
|
|
|
f.close() |
|
|
|
else: |
|
|
|
print(" %s unmodified" % ipy) |
|
|
|
do_vcs_install(versionfile_source, ipy) |
|
|
|
|
|
|
|
def get_cmdclass(): |
|
|
|
return {'version': cmd_version, |
|
|
|
'update_files': cmd_update_files, |
|
|
|
'build_py': cmd_build_py, |
|
|
|
'sdist': cmd_sdist, |
|
|
|
} |
