diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..298116b --- /dev/null +++ b/.gitattributes @@ -0,0 +1 @@ +ciso/_version.py export-subst diff --git a/.travis.yml b/.travis.yml index 384d0ce..a46100d 100644 --- a/.travis.yml +++ b/.travis.yml @@ -1,19 +1,34 @@ -language: python +language: minimal -env: - - CONDA="python=2.7" - - CONDA="python=3.4" - - CONDA="python=3.5" +sudo: false + +matrix: + fast_finish: true + include: + - name: "default" + env: PY=3.7 + - name: "coding_standards" + env: PY=3.7 before_install: - - wget http://bit.ly/miniconda -O miniconda.sh - - bash miniconda.sh -b -p $HOME/miniconda - - export PATH="$HOME/miniconda/bin:$PATH" - - conda update --yes conda - - travis_retry conda create --yes -n TEST $CONDA --file requirements.txt - - source activate TEST - - travis_retry conda install --yes pytest + - wget http://bit.ly/miniconda -O miniconda.sh + - bash miniconda.sh -b -p $HOME/miniconda + - export PATH="$HOME/miniconda/bin:$PATH" + - conda config --set always_yes yes --set changeps1 no --set show_channel_urls true + - conda update conda --quiet + - conda config --add channels conda-forge --force + - conda create --name TEST python=$PY --file requirements.txt --file requirements-dev.txt + - source activate TEST + +install: + - python setup.py sdist && version=$(python setup.py --version) && pushd dist && pip install --no-deps --force-reinstall ciso-${version}.tar.gz && popd script: - - python setup.py build_ext -i - - python setup.py test + - if [[ $TRAVIS_JOB_NAME == "default" ]]; then + cp -r tests /tmp && cd /tmp ; + pytest -n 2 -rxs --cov=ciso tests ; + fi + + - if [[ $TRAVIS_JOB_NAME == 'coding_standards' ]]; then + pytest --flake8 -m flake8 ; + fi \ No newline at end of file diff --git a/MANIFEST.in b/MANIFEST.in index 590836e..db31b84 100644 --- a/MANIFEST.in +++ b/MANIFEST.in @@ -2,3 +2,5 @@ include README.rst include *.txt include ciso/_ciso.* recursive-include ciso *.py +include versioneer.py +include ciso/_version.py diff --git a/README.rst b/README.rst index 27e8c54..3abac07 100644 --- a/README.rst +++ b/README.rst @@ -1,2 +1,15 @@ ciso ---- + +|PyPI| |Travis| + +.. |PyPI| image:: https://img.shields.io/pypi/v/ciso.svg + :target: https://pypi.python.org/pypi/ciso + :alt: PyPI Package + +.. |Travis| image:: https://travis-ci.org/ioos/ciso.svg?branch=master + :target: https://travis-ci.org/ioos/ciso + :alt: Travis Build Status + + +Fast cythonized code for iso-slices of ocean models properties diff --git a/ciso/__init__.py b/ciso/__init__.py index 5f109f2..11b1087 100644 --- a/ciso/__init__.py +++ b/ciso/__init__.py @@ -1,5 +1,8 @@ -__version__ = '0.0.1' - from .ciso import zslice -__all__ = ['zslice'] +__all__ = ["zslice"] + +from ._version import get_versions + +__version__ = get_versions()["version"] +del get_versions diff --git a/ciso/_version.py b/ciso/_version.py new file mode 100644 index 0000000..4a048c8 --- /dev/null +++ b/ciso/_version.py @@ -0,0 +1,566 @@ +# 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 = "v" + cfg.parentdir_prefix = "" + cfg.versionfile_source = "ciso/_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, + } diff --git a/ciso/ciso.py b/ciso/ciso.py index 3ae8b23..b90c633 100644 --- a/ciso/ciso.py +++ b/ciso/ciso.py @@ -1,5 +1,3 @@ -from __future__ import (absolute_import, division, print_function) - import numpy as np from ._ciso import _zslice @@ -41,7 +39,7 @@ def zslice(q, p, p0): p = np.asfarray(p) if q.ndim == 3: - K, J, I = q.shape + K, J, I = q.shape # noqa iso = _zslice(q.reshape(K, -1), p.reshape(K, -1), p0) return iso.reshape(J, I) elif q.ndim == 2: diff --git a/ciso/tests/test_ciso.py b/ciso/tests/test_ciso.py deleted file mode 100644 index a95a9e1..0000000 --- a/ciso/tests/test_ciso.py +++ /dev/null @@ -1,100 +0,0 @@ -from __future__ import (absolute_import, division, print_function) - -import os - -import numpy as np -import pytest - -from ciso import zslice - -data_path = os.path.join(os.path.dirname(__file__), 'data') - - -@pytest.fixture -def data(): - p = np.linspace(-100, 0, 30)[:, None, None] * np.ones((50, 70)) - x, y = np.mgrid[0:20:50j, 0:20:70j] - q = np.sin(x) + p - return q, p, x, y - - -@pytest.fixture -def expected_results(): - return np.load(os.path.join(data_path, 'fortran.npz'))['s50'] - - -def test_mismatch_shapes(): - q, p, x, y = data() - with pytest.raises(ValueError): - zslice(q, p[0], p0=0) - - -def test_p0_wrong_shape(): - q, p, x, y = data() - with pytest.raises(ValueError): - zslice(q, p, p0=np.zeros((2, 2))) - - -def test_bad_dtypes(): - # FIXME: Boolean array are converted to float! Only str fails correctly. - q, p, x, y = data() - with pytest.raises(ValueError): - zslice(np.empty_like(q, dtype=np.str_), p, p0=0) - - -def test_good_dtypes(): - # FIXME: Using `np.asfarray` will prevent from using complex dtypes. - # NOTE: There is probably a more "numpy" efficient way to test this. - q, p, x, y = data() - dtypes = [int, float, np.integer, np.float16, np.float32, - np.float64, np.float128, np.floating] - for dtype in dtypes: - zslice(np.empty_like(q, dtype=dtype), p, p0=0) - - -def test_3D_input(): - q, p, x, y = data() - K, I, J = q.shape - s50 = zslice(q, p, p0=-50) - assert s50.shape == (I, J) - - -def test_2D_input(): - q, p, x, y = data() - K, I, J = q.shape - s50 = zslice(q.reshape(K, -1), p.reshape(K, -1), p0=-50) - assert s50.shape == (I*J,) - - -def test_1D_input(): - q, p, x, y = data() - with pytest.raises(ValueError): - zslice(q.ravel(), p.ravel(), p0=0) - - -def test_gt_3D_input(): - q, p, x, y = data() - with pytest.raises(ValueError): - zslice(q[np.newaxis, ...], p[np.newaxis, ...], p0=0) - - -def test_corret_results_3D(): - q, p, x, y = data() - s50 = zslice(q, p, p0=-50) - f50 = expected_results() - np.testing.assert_almost_equal(s50, f50) - - -def test_corret_results_2D(): - q, p, x, y = data() - K, I, J = q.shape - s50 = zslice(q.reshape(K, -1), p.reshape(K, -1), p0=-50) - f50 = expected_results() - np.testing.assert_almost_equal(s50, f50.ravel()) - - -def test_p0_outside_bounds(): - with pytest.raises(ValueError): - q, p, x, y = data() - K, I, J = q.shape - zslice(q, p, p0=50) diff --git a/notebooks/ciso_FVCOM_example.ipynb b/notebooks/ciso_FVCOM_example.ipynb index 5dc6959..f630f92 100644 --- a/notebooks/ciso_FVCOM_example.ipynb +++ b/notebooks/ciso_FVCOM_example.ipynb @@ -3,9 +3,7 @@ { "cell_type": "code", "execution_count": 1, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "import warnings\n", @@ -13,20 +11,18 @@ "import iris\n", "\n", "\n", - "url = 'http://crow.marine.usf.edu:8080/thredds/dodsC/FVCOM-Nowcast-Agg.nc'\n", + "url = 'http://www.smast.umassd.edu:8080/thredds/dodsC/FVCOM/NECOFS/Forecasts/NECOFS_GOM3_FORECAST.nc'\n", "\n", "\n", "with warnings.catch_warnings():\n", - " warnings.simplefilter(\"ignore\")\n", + " warnings.simplefilter('ignore')\n", " cubes = iris.load_raw(url)" ] }, { "cell_type": "code", "execution_count": 2, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [ "salt = cubes.extract_strict('sea_water_salinity')[-1, ...] # Last time step.\n", @@ -38,9 +34,7 @@ { "cell_type": "code", "execution_count": 3, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [ "p = salt.coord('sea_surface_height_above_reference_ellipsoid').points\n", @@ -50,9 +44,7 @@ { "cell_type": "code", "execution_count": 4, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", @@ -67,9 +59,7 @@ { "cell_type": "code", "execution_count": 5, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [ "import numpy.ma as ma\n", @@ -83,9 +73,7 @@ { "cell_type": "code", "execution_count": 6, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [ "%matplotlib inline\n", @@ -112,69 +100,33 @@ { "cell_type": "code", "execution_count": 7, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [ - "import pyugrid\n", - "import matplotlib.tri as tri\n", - "\n", - "ugrid = pyugrid.UGrid.from_ncfile(url)\n", + "import gridgeo\n", "\n", - "lon = ugrid.nodes[:, 0]\n", - "lat = ugrid.nodes[:, 1]\n", - "triangles = ugrid.faces[:]\n", "\n", - "triang = tri.Triangulation(lon, lat, triangles=triangles)" + "grid = gridgeo.GridGeo(\n", + " url,\n", + " standard_name='sea_water_salinity'\n", + ")" ] }, { "cell_type": "code", "execution_count": 8, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [ { "data": { + "image/png": "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\n", "text/plain": [ - "" + "
" ] }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "cmap" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/filipe/miniconda/envs/IOOS/lib/python2.7/site-packages/matplotlib/artist.py:221: MatplotlibDeprecationWarning: This has been deprecated in mpl 1.5, please use the\n", - "axes property. A removal date has not been set.\n", - " warnings.warn(_get_axes_msg, mplDeprecation, stacklevel=1)\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhoAAAGECAYAAABwPYmIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAAAAAElFTkSuQmCC\n", - "text/plain": [ - "" - ] + "metadata": { + "needs_background": "light" }, - "metadata": {}, "output_type": "display_data" } ], @@ -187,7 +139,7 @@ "levels = np.linspace(vmin, vmax, 20)\n", "\n", "kw = dict(cmap=cmap, alpha=0.9, levels=levels)\n", - "cs = ax.tricontourf(triang, isoslice, **kw)\n", + "cs = ax.tricontourf(grid.triang, isoslice, **kw)\n", "kw = dict(shrink=0.5, orientation='vertical')\n", "cbar = fig.colorbar(cs, **kw)" ] @@ -195,23 +147,23 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 2", + "display_name": "Python 3", "language": "python", - "name": "python2" + "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", - "version": 2 + "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", - "pygments_lexer": "ipython2", - "version": "2.7.11" + "pygments_lexer": "ipython3", + "version": "3.7.1" } }, "nbformat": 4, - "nbformat_minor": 0 + "nbformat_minor": 1 } diff --git a/notebooks/ciso_ROMS_example.ipynb b/notebooks/ciso_ROMS_example.ipynb index 2da8d13..2a2dd56 100644 --- a/notebooks/ciso_ROMS_example.ipynb +++ b/notebooks/ciso_ROMS_example.ipynb @@ -3,9 +3,7 @@ { "cell_type": "code", "execution_count": 1, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "import warnings\n", @@ -25,9 +23,7 @@ { "cell_type": "code", "execution_count": 2, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [ "salt = cubes.extract_strict('sea_water_salinity')[-1, ...] # Last time step.\n", @@ -39,9 +35,7 @@ { "cell_type": "code", "execution_count": 3, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [ "p = salt.coord('sea_surface_height_above_reference_ellipsoid').points\n", @@ -51,9 +45,7 @@ { "cell_type": "code", "execution_count": 4, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", @@ -68,9 +60,7 @@ { "cell_type": "code", "execution_count": 5, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [ "%matplotlib inline\n", @@ -101,27 +91,18 @@ { "cell_type": "code", "execution_count": 6, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/filipe/miniconda/envs/IOOS/lib/python2.7/site-packages/matplotlib/artist.py:221: MatplotlibDeprecationWarning: This has been deprecated in mpl 1.5, please use the\n", - "axes property. A removal date has not been set.\n", - " warnings.warn(_get_axes_msg, mplDeprecation, stacklevel=1)\n" - ] - }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgIAAAF5CAYAAADtSEJTAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAElFTkSuQmCC\n", + "image/png": "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\n", "text/plain": [ - "" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -139,23 +120,23 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 2", + "display_name": "Python 3", "language": "python", - "name": "python2" + "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", - "version": 2 + "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", - "pygments_lexer": "ipython2", - "version": "2.7.11" + "pygments_lexer": "ipython3", + "version": "3.7.1" } }, "nbformat": 4, - "nbformat_minor": 0 + "nbformat_minor": 1 } diff --git a/requirements-dev.txt b/requirements-dev.txt new file mode 100644 index 0000000..90ae633 --- /dev/null +++ b/requirements-dev.txt @@ -0,0 +1,15 @@ +black +flake8 +flake8-builtins +flake8-comprehensions +flake8-mutable +flake8-print +gridgeo +iris +isort +pycodestyle +pytest +pytest-cov +pytest-flake8 +pytest-xdist +twine diff --git a/requirements.txt b/requirements.txt index 246f48d..7933e57 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,3 +1,2 @@ -numpy cython -setuptools +numpy diff --git a/setup.cfg b/setup.cfg new file mode 100644 index 0000000..9fb3078 --- /dev/null +++ b/setup.cfg @@ -0,0 +1,14 @@ +[versioneer] +VCS = git +style = pep440 +versionfile_source = ciso/_version.py +versionfile_build = ciso/_version.py +tag_prefix = v +parentdir_prefix = + +[tool:pytest] +flake8-max-line-length = 105 +flake8-ignore = + docs/* ALL + versioneer.py ALL + ciso/_version.py ALL \ No newline at end of file diff --git a/setup.py b/setup.py index 02f5cf4..b21ffbf 100644 --- a/setup.py +++ b/setup.py @@ -1,77 +1,57 @@ import os -import sys -import numpy -from setuptools import Extension, setup -from setuptools.command.test import test as TestCommand +import numpy from Cython.Build import cythonize +from setuptools import Extension, setup - -class PyTest(TestCommand): - def finalize_options(self): - TestCommand.finalize_options(self) - self.verbose = True - - def run_tests(self): - import pytest - errno = pytest.main(self.test_args) - sys.exit(errno) - - -def extract_version(module='ciso'): - version = None - fdir = os.path.dirname(__file__) - fnme = os.path.join(fdir, module, '__init__.py') - with open(fnme) as fd: - for line in fd: - if (line.startswith('__version__')): - _, version = line.split('=') - # Remove quotation characters. - version = version.strip()[1:-1] - break - return version +import versioneer rootpath = os.path.abspath(os.path.dirname(__file__)) def read(*parts): - return open(os.path.join(rootpath, *parts), 'r').read() + return open(os.path.join(rootpath, *parts), "r").read() -long_description = '{}\n{}'.format(read('README.rst'), read('CHANGES.txt')) -LICENSE = read('LICENSE.txt') +long_description = "{}\n{}".format(read("README.rst"), read("CHANGES.txt")) +LICENSE = read("LICENSE.txt") -with open('requirements.txt') as f: +with open("requirements.txt") as f: require = f.readlines() install_requires = [r.strip() for r in require] -extensions = [Extension("ciso._ciso", ['ciso/_ciso.pyx'], - include_dirs=[numpy.get_include()])] - -setup(name="ciso", - version=extract_version(), - license=LICENSE, - long_description=long_description, - classifiers=['Development Status :: 5 - Production/Stable', - 'Environment :: Console', - 'Intended Audience :: Science/Research', - 'Intended Audience :: Developers', - 'Intended Audience :: Education', - 'License :: OSI Approved :: MIT License', - 'Operating System :: OS Independent', - 'Programming Language :: Python', - 'Topic :: Scientific/Engineering', - 'Topic :: Education', - ], - description='Create isosurfaces from 2D or 3D arrays', - url='https://github.com/ioos/ciso', - platforms='any', - keywords=['oceanography', 'isosurfaces', 'APIRUS'], - install_requires=install_requires, - packages=['ciso'], - tests_require=['pytest'], - cmdclass=dict(test=PyTest), - ext_modules=cythonize(extensions), - author=["Robert Hetland"], - author_email="hetland@tamu.edu", - ) +extensions = [ + Extension( + "ciso._ciso", ["ciso/_ciso.pyx"], include_dirs=[numpy.get_include()] + ) +] + +setup( + name="ciso", + version=versioneer.get_version(), + license=LICENSE, + long_description=long_description, + classifiers=[ + "Development Status :: 5 - Production/Stable", + "Environment :: Console", + "Intended Audience :: Science/Research", + "Intended Audience :: Developers", + "Intended Audience :: Education", + "License :: OSI Approved :: MIT License", + "Operating System :: OS Independent", + "Programming Language :: Python", + "Topic :: Scientific/Engineering", + "Topic :: Education", + ], + description="Create isosurfaces from 2D or 3D arrays", + url="https://github.com/ioos/ciso", + platforms="any", + keywords=["oceanography", "isosurfaces", "APIRUS"], + install_requires=install_requires, + packages=["ciso"], + tests_require=["pytest"], + cmdclass=versioneer.get_cmdclass(), + ext_modules=cythonize(extensions), + author=["Robert Hetland"], + author_email="hetland@tamu.edu", +) diff --git a/ciso/tests/data/fortran.npz b/tests/data/fortran.npz similarity index 100% rename from ciso/tests/data/fortran.npz rename to tests/data/fortran.npz diff --git a/tests/test_ciso.py b/tests/test_ciso.py new file mode 100644 index 0000000..912f398 --- /dev/null +++ b/tests/test_ciso.py @@ -0,0 +1,95 @@ +from __future__ import absolute_import, division, print_function + +import os + +import numpy as np +import pytest + +from ciso import zslice + +data_path = os.path.join(os.path.dirname(__file__), "data") + + +@pytest.fixture +def data(): + p = np.linspace(-100, 0, 30)[:, None, None] * np.ones((50, 70)) + x, y = np.mgrid[0:20:50j, 0:20:70j] + q = np.sin(x) + p + yield {"q": q, "p": p, "x": x, "y": y} + + +@pytest.fixture +def expected_results(): + yield np.load(os.path.join(data_path, "fortran.npz"))["s50"] + + +def test_mismatch_shapes(data): + with pytest.raises(ValueError): + zslice(data["q"], data["p"][0], p0=0) + + +def test_p0_wrong_shape(data): + with pytest.raises(ValueError): + zslice(data["q"], data["p"], p0=np.zeros((2, 2))) + + +def test_bad_dtypes(data): + # FIXME: Boolean array are converted to float! Only str fails correctly. + with pytest.raises(ValueError): + zslice(np.empty_like(data["q"], dtype=np.str_), data["p"], p0=0) + + +def test_good_dtypes(data): + # FIXME: Using `np.asfarray` will prevent from using complex dtypes. + # NOTE: There is probably a more "numpy" efficient way to test this. + dtypes = [ + int, + float, + np.integer, + np.float16, + np.float32, + np.float64, + np.float128, + np.floating, + ] + for dtype in dtypes: + zslice(np.empty_like(data["q"], dtype=dtype), data["p"], p0=0) + + +def test_3D_input(data): + K, I, J = data["q"].shape + s50 = zslice(data["q"], data["p"], p0=-50) + assert s50.shape == (I, J) + + +def test_2D_input(data): + K, I, J = data["q"].shape + s50 = zslice(data["q"].reshape(K, -1), data["p"].reshape(K, -1), p0=-50) + assert s50.shape == (I * J,) + + +def test_1D_input(data): + with pytest.raises(ValueError): + zslice(data["q"].ravel(), data["p"].ravel(), p0=0) + + +def test_gt_3D_input(data): + with pytest.raises(ValueError): + zslice(data["q"][np.newaxis, ...], data["p"][np.newaxis, ...], p0=0) + + +def test_corret_results_3D(data, expected_results): + s50 = zslice(data["q"], data["p"], p0=-50) + np.testing.assert_almost_equal(s50, expected_results) + + +def test_corret_results_2D(data, expected_results): + K, I, J = data["q"].shape + s50 = zslice(data["q"].reshape(K, -1), data["p"].reshape(K, -1), p0=-50) + np.testing.assert_almost_equal(s50, expected_results.ravel()) + + +def test_p0_outside_bounds(data): + with pytest.raises(ValueError): + K, I, J = data["q"].shape + zslice(data["q"], data["p"], p0=50) diff --git a/versioneer.py b/versioneer.py new file mode 100644 index 0000000..1be4fa4 --- /dev/null +++ b/versioneer.py @@ -0,0 +1,1904 @@ +# Version: 0.18 + +"""The Versioneer - like a rocketeer, but for versions. + +The Versioneer +============== + +* like a rocketeer, but for versions! +* https://github.com/warner/python-versioneer +* Brian Warner +* License: Public Domain +* Compatible With: python2.6, 2.7, 3.2, 3.3, 3.4, 3.5, 3.6, and pypy +* [![Latest Version] +(https://pypip.in/version/versioneer/badge.svg?style=flat) +](https://pypi.python.org/pypi/versioneer/) +* [![Build Status] +(https://travis-ci.org/warner/python-versioneer.png?branch=master) +](https://travis-ci.org/warner/python-versioneer) + +This is a tool for managing a recorded version number in distutils-based +python projects. The goal is to remove the tedious and error-prone "update +the embedded version string" step from your release process. Making a new +release should be as easy as recording a new tag in your version-control +system, and maybe making new tarballs. + + +## Quick Install + +* `pip install versioneer` to somewhere to your $PATH +* add a `[versioneer]` section to your setup.cfg (see below) +* run `versioneer install` in your source tree, commit the results + +## Version Identifiers + +Source trees come from a variety of places: + +* a version-control system checkout (mostly used by developers) +* a nightly tarball, produced by build automation +* a snapshot tarball, produced by a web-based VCS browser, like github's + "tarball from tag" feature +* a release tarball, produced by "setup.py sdist", distributed through PyPI + +Within each source tree, the version identifier (either a string or a number, +this tool is format-agnostic) can come from a variety of places: + +* ask the VCS tool itself, e.g. "git describe" (for checkouts), which knows + about recent "tags" and an absolute revision-id +* the name of the directory into which the tarball was unpacked +* an expanded VCS keyword ($Id$, etc) +* a `_version.py` created by some earlier build step + +For released software, the version identifier is closely related to a VCS +tag. Some projects use tag names that include more than just the version +string (e.g. "myproject-1.2" instead of just "1.2"), in which case the tool +needs to strip the tag prefix to extract the version identifier. For +unreleased software (between tags), the version identifier should provide +enough information to help developers recreate the same tree, while also +giving them an idea of roughly how old the tree is (after version 1.2, before +version 1.3). Many VCS systems can report a description that captures this, +for example `git describe --tags --dirty --always` reports things like +"0.7-1-g574ab98-dirty" to indicate that the checkout is one revision past the +0.7 tag, has a unique revision id of "574ab98", and is "dirty" (it has +uncommitted changes. + +The version identifier is used for multiple purposes: + +* to allow the module to self-identify its version: `myproject.__version__` +* to choose a name and prefix for a 'setup.py sdist' tarball + +## Theory of Operation + +Versioneer works by adding a special `_version.py` file into your source +tree, where your `__init__.py` can import it. This `_version.py` knows how to +dynamically ask the VCS tool for version information at import time. + +`_version.py` also contains `$Revision$` markers, and the installation +process marks `_version.py` to have this marker rewritten with a tag name +during the `git archive` command. As a result, generated tarballs will +contain enough information to get the proper version. + +To allow `setup.py` to compute a version too, a `versioneer.py` is added to +the top level of your source tree, next to `setup.py` and the `setup.cfg` +that configures it. This overrides several distutils/setuptools commands to +compute the version when invoked, and changes `setup.py build` and `setup.py +sdist` to replace `_version.py` with a small static file that contains just +the generated version data. + +## Installation + +See [INSTALL.md](./INSTALL.md) for detailed installation instructions. + +## Version-String Flavors + +Code which uses Versioneer can learn about its version string at runtime by +importing `_version` from your main `__init__.py` file and running the +`get_versions()` function. From the "outside" (e.g. in `setup.py`), you can +import the top-level `versioneer.py` and run `get_versions()`. + +Both functions return a dictionary with different flavors of version +information: + +* `['version']`: A condensed version string, rendered using the selected + style. This is the most commonly used value for the project's version + string. The default "pep440" style yields strings like `0.11`, + `0.11+2.g1076c97`, or `0.11+2.g1076c97.dirty`. See the "Styles" section + below for alternative styles. + +* `['full-revisionid']`: detailed revision identifier. For Git, this is the + full SHA1 commit id, e.g. "1076c978a8d3cfc70f408fe5974aa6c092c949ac". + +* `['date']`: Date and time of the latest `HEAD` commit. For Git, it is the + commit date in ISO 8601 format. This will be None if the date is not + available. + +* `['dirty']`: a boolean, True if the tree has uncommitted changes. Note that + this is only accurate if run in a VCS checkout, otherwise it is likely to + be False or None + +* `['error']`: if the version string could not be computed, this will be set + to a string describing the problem, otherwise it will be None. It may be + useful to throw an exception in setup.py if this is set, to avoid e.g. + creating tarballs with a version string of "unknown". + +Some variants are more useful than others. Including `full-revisionid` in a +bug report should allow developers to reconstruct the exact code being tested +(or indicate the presence of local changes that should be shared with the +developers). `version` is suitable for display in an "about" box or a CLI +`--version` output: it can be easily compared against release notes and lists +of bugs fixed in various releases. + +The installer adds the following text to your `__init__.py` to place a basic +version in `YOURPROJECT.__version__`: + + from ._version import get_versions + __version__ = get_versions()['version'] + del get_versions + +## Styles + +The setup.cfg `style=` configuration controls how the VCS information is +rendered into a version string. + +The default style, "pep440", produces a PEP440-compliant string, equal to the +un-prefixed tag name for actual releases, and containing an additional "local +version" section with more detail for in-between builds. For Git, this is +TAG[+DISTANCE.gHEX[.dirty]] , using information from `git describe --tags +--dirty --always`. For example "0.11+2.g1076c97.dirty" indicates that the +tree is like the "1076c97" commit but has uncommitted changes (".dirty"), and +that this commit is two revisions ("+2") beyond the "0.11" tag. For released +software (exactly equal to a known tag), the identifier will only contain the +stripped tag, e.g. "0.11". + +Other styles are available. See [details.md](details.md) in the Versioneer +source tree for descriptions. + +## Debugging + +Versioneer tries to avoid fatal errors: if something goes wrong, it will tend +to return a version of "0+unknown". To investigate the problem, run `setup.py +version`, which will run the version-lookup code in a verbose mode, and will +display the full contents of `get_versions()` (including the `error` string, +which may help identify what went wrong). + +## Known Limitations + +Some situations are known to cause problems for Versioneer. This details the +most significant ones. More can be found on Github +[issues page](https://github.com/warner/python-versioneer/issues). + +### Subprojects + +Versioneer has limited support for source trees in which `setup.py` is not in +the root directory (e.g. `setup.py` and `.git/` are *not* siblings). The are +two common reasons why `setup.py` might not be in the root: + +* Source trees which contain multiple subprojects, such as + [Buildbot](https://github.com/buildbot/buildbot), which contains both + "master" and "slave" subprojects, each with their own `setup.py`, + `setup.cfg`, and `tox.ini`. Projects like these produce multiple PyPI + distributions (and upload multiple independently-installable tarballs). +* Source trees whose main purpose is to contain a C library, but which also + provide bindings to Python (and perhaps other langauges) in subdirectories. + +Versioneer will look for `.git` in parent directories, and most operations +should get the right version string. However `pip` and `setuptools` have bugs +and implementation details which frequently cause `pip install .` from a +subproject directory to fail to find a correct version string (so it usually +defaults to `0+unknown`). + +`pip install --editable .` should work correctly. `setup.py install` might +work too. + +Pip-8.1.1 is known to have this problem, but hopefully it will get fixed in +some later version. + +[Bug #38](https://github.com/warner/python-versioneer/issues/38) is tracking +this issue. The discussion in +[PR #61](https://github.com/warner/python-versioneer/pull/61) describes the +issue from the Versioneer side in more detail. +[pip PR#3176](https://github.com/pypa/pip/pull/3176) and +[pip PR#3615](https://github.com/pypa/pip/pull/3615) contain work to improve +pip to let Versioneer work correctly. + +Versioneer-0.16 and earlier only looked for a `.git` directory next to the +`setup.cfg`, so subprojects were completely unsupported with those releases. + +### Editable installs with setuptools <= 18.5 + +`setup.py develop` and `pip install --editable .` allow you to install a +project into a virtualenv once, then continue editing the source code (and +test) without re-installing after every change. + +"Entry-point scripts" (`setup(entry_points={"console_scripts": ..})`) are a +convenient way to specify executable scripts that should be installed along +with the python package. + +These both work as expected when using modern setuptools. When using +setuptools-18.5 or earlier, however, certain operations will cause +`pkg_resources.DistributionNotFound` errors when running the entrypoint +script, which must be resolved by re-installing the package. This happens +when the install happens with one version, then the egg_info data is +regenerated while a different version is checked out. Many setup.py commands +cause egg_info to be rebuilt (including `sdist`, `wheel`, and installing into +a different virtualenv), so this can be surprising. + +[Bug #83](https://github.com/warner/python-versioneer/issues/83) describes +this one, but upgrading to a newer version of setuptools should probably +resolve it. + +### Unicode version strings + +While Versioneer works (and is continually tested) with both Python 2 and +Python 3, it is not entirely consistent with bytes-vs-unicode distinctions. +Newer releases probably generate unicode version strings on py2. It's not +clear that this is wrong, but it may be surprising for applications when then +write these strings to a network connection or include them in bytes-oriented +APIs like cryptographic checksums. + +[Bug #71](https://github.com/warner/python-versioneer/issues/71) investigates +this question. + + +## Updating Versioneer + +To upgrade your project to a new release of Versioneer, do the following: + +* install the new Versioneer (`pip install -U versioneer` or equivalent) +* edit `setup.cfg`, if necessary, to include any new configuration settings + indicated by the release notes. See [UPGRADING](./UPGRADING.md) for details. +* re-run `versioneer install` in your source tree, to replace + `SRC/_version.py` +* commit any changed files + +## Future Directions + +This tool is designed to make it easily extended to other version-control +systems: all VCS-specific components are in separate directories like +src/git/ . The top-level `versioneer.py` script is assembled from these +components by running make-versioneer.py . In the future, make-versioneer.py +will take a VCS name as an argument, and will construct a version of +`versioneer.py` that is specific to the given VCS. It might also take the +configuration arguments that are currently provided manually during +installation by editing setup.py . Alternatively, it might go the other +direction and include code from all supported VCS systems, reducing the +number of intermediate scripts. + + +## License + +To make Versioneer easier to embed, all its code is dedicated to the public +domain. The `_version.py` that it creates is also in the public domain. +Specifically, both are released under the Creative Commons "Public Domain +Dedication" license (CC0-1.0), as described in +https://creativecommons.org/publicdomain/zero/1.0/ . + +""" + +from __future__ import print_function + +import errno +import json +import os +import re +import subprocess +import sys + +try: + import configparser +except ImportError: + import ConfigParser as configparser + + +class VersioneerConfig: + """Container for Versioneer configuration parameters.""" + + +def get_root(): + """Get the project root directory. + + We require that all commands are run from the project root, i.e. the + directory that contains setup.py, setup.cfg, and versioneer.py . + """ + root = os.path.realpath(os.path.abspath(os.getcwd())) + setup_py = os.path.join(root, "setup.py") + versioneer_py = os.path.join(root, "versioneer.py") + if not (os.path.exists(setup_py) or os.path.exists(versioneer_py)): + # allow 'python path/to/setup.py COMMAND' + root = os.path.dirname(os.path.realpath(os.path.abspath(sys.argv[0]))) + setup_py = os.path.join(root, "setup.py") + versioneer_py = os.path.join(root, "versioneer.py") + if not (os.path.exists(setup_py) or os.path.exists(versioneer_py)): + err = ( + "Versioneer was unable to run the project root directory. " + "Versioneer requires setup.py to be executed from " + "its immediate directory (like 'python setup.py COMMAND'), " + "or in a way that lets it use sys.argv[0] to find the root " + "(like 'python path/to/setup.py COMMAND')." + ) + raise VersioneerBadRootError(err) + try: + # Certain runtime workflows (setup.py install/develop in a setuptools + # tree) execute all dependencies in a single python process, so + # "versioneer" may be imported multiple times, and python's shared + # module-import table will cache the first one. So we can't use + # os.path.dirname(__file__), as that will find whichever + # versioneer.py was first imported, even in later projects. + me = os.path.realpath(os.path.abspath(__file__)) + me_dir = os.path.normcase(os.path.splitext(me)[0]) + vsr_dir = os.path.normcase(os.path.splitext(versioneer_py)[0]) + if me_dir != vsr_dir: + print( + "Warning: build in %s is using versioneer.py from %s" + % (os.path.dirname(me), versioneer_py) + ) + except NameError: + pass + return root + + +def get_config_from_root(root): + """Read the project setup.cfg file to determine Versioneer config.""" + # This might raise EnvironmentError (if setup.cfg is missing), or + # configparser.NoSectionError (if it lacks a [versioneer] section), or + # configparser.NoOptionError (if it lacks "VCS="). See the docstring at + # the top of versioneer.py for instructions on writing your setup.cfg . + setup_cfg = os.path.join(root, "setup.cfg") + parser = configparser.SafeConfigParser() + with open(setup_cfg, "r") as f: + parser.readfp(f) + VCS = parser.get("versioneer", "VCS") # mandatory + + def get(parser, name): + if parser.has_option("versioneer", name): + return parser.get("versioneer", name) + return None + + cfg = VersioneerConfig() + cfg.VCS = VCS + cfg.style = get(parser, "style") or "" + cfg.versionfile_source = get(parser, "versionfile_source") + cfg.versionfile_build = get(parser, "versionfile_build") + cfg.tag_prefix = get(parser, "tag_prefix") + if cfg.tag_prefix in ("''", '""'): + cfg.tag_prefix = "" + cfg.parentdir_prefix = get(parser, "parentdir_prefix") + cfg.verbose = get(parser, "verbose") + return cfg + + +class NotThisMethod(Exception): + """Exception raised if a method is not valid for the current scenario.""" + + +# these dictionaries contain VCS-specific tools +LONG_VERSION_PY = {} +HANDLERS = {} + + +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 + + +LONG_VERSION_PY[ + "git" +] = ''' +# 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 = "%(DOLLAR)sFormat:%%d%(DOLLAR)s" + git_full = "%(DOLLAR)sFormat:%%H%(DOLLAR)s" + git_date = "%(DOLLAR)sFormat:%%ci%(DOLLAR)s" + 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 = "%(STYLE)s" + cfg.tag_prefix = "%(TAG_PREFIX)s" + cfg.parentdir_prefix = "%(PARENTDIR_PREFIX)s" + cfg.versionfile_source = "%(VERSIONFILE_SOURCE)s" + 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} +''' + + +@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 do_vcs_install(manifest_in, versionfile_source, ipy): + """Git-specific installation logic for Versioneer. + + For Git, this means creating/changing .gitattributes to mark _version.py + for export-subst keyword substitution. + """ + GITS = ["git"] + if sys.platform == "win32": + GITS = ["git.cmd", "git.exe"] + files = [manifest_in, versionfile_source] + if ipy: + files.append(ipy) + try: + me = __file__ + if me.endswith(".pyc") or me.endswith(".pyo"): + me = os.path.splitext(me)[0] + ".py" + versioneer_file = os.path.relpath(me) + except NameError: + versioneer_file = "versioneer.py" + files.append(versioneer_file) + present = False + try: + f = open(".gitattributes", "r") + for line in f.readlines(): + if line.strip().startswith(versionfile_source): + if "export-subst" in line.strip().split()[1:]: + present = True + f.close() + except EnvironmentError: + pass + if not present: + f = open(".gitattributes", "a+") + f.write("%s export-subst\n" % versionfile_source) + f.close() + files.append(".gitattributes") + run_command(GITS, ["add", "--"] + files) + + +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") + + +SHORT_VERSION_PY = """ +# This file was generated by 'versioneer.py' (0.18) 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. + +import json + +version_json = ''' +%s +''' # END VERSION_JSON + + +def get_versions(): + return json.loads(version_json) +""" + + +def versions_from_file(filename): + """Try to determine the version from _version.py if present.""" + try: + with open(filename) as f: + contents = f.read() + except EnvironmentError: + raise NotThisMethod("unable to read _version.py") + mo = re.search( + r"version_json = '''\n(.*)''' # END VERSION_JSON", + contents, + re.M | re.S, + ) + if not mo: + mo = re.search( + r"version_json = '''\r\n(.*)''' # END VERSION_JSON", + contents, + re.M | re.S, + ) + if not mo: + raise NotThisMethod("no version_json in _version.py") + return json.loads(mo.group(1)) + + +def write_to_version_file(filename, versions): + """Write the given version number to the given _version.py file.""" + os.unlink(filename) + contents = json.dumps( + versions, sort_keys=True, indent=1, separators=(",", ": ") + ) + with open(filename, "w") as f: + f.write(SHORT_VERSION_PY % contents) + + print("set %s to '%s'" % (filename, versions["version"])) + + +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"), + } + + +class VersioneerBadRootError(Exception): + """The project root directory is unknown or missing key files.""" + + +def get_versions(verbose=False): + """Get the project version from whatever source is available. + + Returns dict with two keys: 'version' and 'full'. + """ + if "versioneer" in sys.modules: + # see the discussion in cmdclass.py:get_cmdclass() + del sys.modules["versioneer"] + + root = get_root() + cfg = get_config_from_root(root) + + assert cfg.VCS is not None, "please set [versioneer]VCS= in setup.cfg" + handlers = HANDLERS.get(cfg.VCS) + assert handlers, "unrecognized VCS '%s'" % cfg.VCS + verbose = verbose or cfg.verbose + assert ( + cfg.versionfile_source is not None + ), "please set versioneer.versionfile_source" + assert cfg.tag_prefix is not None, "please set versioneer.tag_prefix" + + versionfile_abs = os.path.join(root, cfg.versionfile_source) + + # extract version from first of: _version.py, VCS command (e.g. '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 or the equivalent in other VCSes. + + get_keywords_f = handlers.get("get_keywords") + from_keywords_f = handlers.get("keywords") + if get_keywords_f and from_keywords_f: + try: + keywords = get_keywords_f(versionfile_abs) + ver = from_keywords_f(keywords, cfg.tag_prefix, verbose) + if verbose: + print("got version from expanded keyword %s" % ver) + return ver + except NotThisMethod: + pass + + try: + ver = versions_from_file(versionfile_abs) + if verbose: + print("got version from file %s %s" % (versionfile_abs, ver)) + return ver + except NotThisMethod: + pass + + from_vcs_f = handlers.get("pieces_from_vcs") + if from_vcs_f: + try: + pieces = from_vcs_f(cfg.tag_prefix, root, verbose) + ver = render(pieces, cfg.style) + if verbose: + print("got version from VCS %s" % ver) + return ver + except NotThisMethod: + pass + + try: + if cfg.parentdir_prefix: + ver = versions_from_parentdir(cfg.parentdir_prefix, root, verbose) + if verbose: + print("got version from parentdir %s" % ver) + return ver + except NotThisMethod: + pass + + if verbose: + print("unable to compute version") + + return { + "version": "0+unknown", + "full-revisionid": None, + "dirty": None, + "error": "unable to compute version", + "date": None, + } + + +def get_version(): + """Get the short version string for this project.""" + return get_versions()["version"] + + +def get_cmdclass(): + """Get the custom setuptools/distutils subclasses used by Versioneer.""" + if "versioneer" in sys.modules: + del sys.modules["versioneer"] + # this fixes the "python setup.py develop" case (also 'install' and + # 'easy_install .'), in which subdependencies of the main project are + # built (using setup.py bdist_egg) in the same python process. Assume + # a main project A and a dependency B, which use different versions + # of Versioneer. A's setup.py imports A's Versioneer, leaving it in + # sys.modules by the time B's setup.py is executed, causing B to run + # with the wrong versioneer. Setuptools wraps the sub-dep builds in a + # sandbox that restores sys.modules to it's pre-build state, so the + # parent is protected against the child's "import versioneer". By + # removing ourselves from sys.modules here, before the child build + # happens, we protect the child from the parent's versioneer too. + # Also see https://github.com/warner/python-versioneer/issues/52 + + cmds = {} + + # we add "version" to both distutils and setuptools + from distutils.core import Command + + 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): + vers = get_versions(verbose=True) + print("Version: %s" % vers["version"]) + print(" full-revisionid: %s" % vers.get("full-revisionid")) + print(" dirty: %s" % vers.get("dirty")) + print(" date: %s" % vers.get("date")) + if vers["error"]: + print(" error: %s" % vers["error"]) + + cmds["version"] = cmd_version + + # we override "build_py" in both distutils and setuptools + # + # most invocation pathways end up running build_py: + # distutils/build -> build_py + # distutils/install -> distutils/build ->.. + # setuptools/bdist_wheel -> distutils/install ->.. + # setuptools/bdist_egg -> distutils/install_lib -> build_py + # setuptools/install -> bdist_egg ->.. + # setuptools/develop -> ? + # pip install: + # copies source tree to a tempdir before running egg_info/etc + # if .git isn't copied too, 'git describe' will fail + # then does setup.py bdist_wheel, or sometimes setup.py install + # setup.py egg_info -> ? + + # we override different "build_py" commands for both environments + if "setuptools" in sys.modules: + from setuptools.command.build_py import build_py as _build_py + else: + from distutils.command.build_py import build_py as _build_py + + class cmd_build_py(_build_py): + def run(self): + root = get_root() + cfg = get_config_from_root(root) + versions = get_versions() + _build_py.run(self) + # now locate _version.py in the new build/ directory and replace + # it with an updated value + if cfg.versionfile_build: + target_versionfile = os.path.join( + self.build_lib, cfg.versionfile_build + ) + print("UPDATING %s" % target_versionfile) + write_to_version_file(target_versionfile, versions) + + cmds["build_py"] = cmd_build_py + + if "cx_Freeze" in sys.modules: # cx_freeze enabled? + from cx_Freeze.dist import build_exe as _build_exe + + # nczeczulin reports that py2exe won't like the pep440-style string + # as FILEVERSION, but it can be used for PRODUCTVERSION, e.g. + # setup(console=[{ + # "version": versioneer.get_version().split("+", 1)[0], # FILEVERSION + # "product_version": versioneer.get_version(), + # ... + + class cmd_build_exe(_build_exe): + def run(self): + root = get_root() + cfg = get_config_from_root(root) + versions = get_versions() + target_versionfile = cfg.versionfile_source + print("UPDATING %s" % target_versionfile) + write_to_version_file(target_versionfile, versions) + + _build_exe.run(self) + os.unlink(target_versionfile) + with open(cfg.versionfile_source, "w") as f: + LONG = LONG_VERSION_PY[cfg.VCS] + f.write( + LONG + % { + "DOLLAR": "$", + "STYLE": cfg.style, + "TAG_PREFIX": cfg.tag_prefix, + "PARENTDIR_PREFIX": cfg.parentdir_prefix, + "VERSIONFILE_SOURCE": cfg.versionfile_source, + } + ) + + cmds["build_exe"] = cmd_build_exe + del cmds["build_py"] + + if "py2exe" in sys.modules: # py2exe enabled? + try: + from py2exe.distutils_buildexe import py2exe as _py2exe # py3 + except ImportError: + from py2exe.build_exe import py2exe as _py2exe # py2 + + class cmd_py2exe(_py2exe): + def run(self): + root = get_root() + cfg = get_config_from_root(root) + versions = get_versions() + target_versionfile = cfg.versionfile_source + print("UPDATING %s" % target_versionfile) + write_to_version_file(target_versionfile, versions) + + _py2exe.run(self) + os.unlink(target_versionfile) + with open(cfg.versionfile_source, "w") as f: + LONG = LONG_VERSION_PY[cfg.VCS] + f.write( + LONG + % { + "DOLLAR": "$", + "STYLE": cfg.style, + "TAG_PREFIX": cfg.tag_prefix, + "PARENTDIR_PREFIX": cfg.parentdir_prefix, + "VERSIONFILE_SOURCE": cfg.versionfile_source, + } + ) + + cmds["py2exe"] = cmd_py2exe + + # we override different "sdist" commands for both environments + if "setuptools" in sys.modules: + from setuptools.command.sdist import sdist as _sdist + else: + from distutils.command.sdist import sdist as _sdist + + class cmd_sdist(_sdist): + def run(self): + versions = get_versions() + 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): + root = get_root() + cfg = get_config_from_root(root) + _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, cfg.versionfile_source) + print("UPDATING %s" % target_versionfile) + write_to_version_file( + target_versionfile, self._versioneer_generated_versions + ) + + cmds["sdist"] = cmd_sdist + + return cmds + + +CONFIG_ERROR = """ +setup.cfg is missing the necessary Versioneer configuration. You need +a section like: + + [versioneer] + VCS = git + style = pep440 + versionfile_source = src/myproject/_version.py + versionfile_build = myproject/_version.py + tag_prefix = + parentdir_prefix = myproject- + +You will also need to edit your setup.py to use the results: + + import versioneer + setup(version=versioneer.get_version(), + cmdclass=versioneer.get_cmdclass(), ...) + +Please read the docstring in ./versioneer.py for configuration instructions, +edit setup.cfg, and re-run the installer or 'python versioneer.py setup'. +""" + +SAMPLE_CONFIG = """ +# See the docstring in versioneer.py for instructions. Note that you must +# re-run 'versioneer.py setup' after changing this section, and commit the +# resulting files. + +[versioneer] +#VCS = git +#style = pep440 +#versionfile_source = +#versionfile_build = +#tag_prefix = +#parentdir_prefix = + +""" + +INIT_PY_SNIPPET = """ +from ._version import get_versions +__version__ = get_versions()['version'] +del get_versions +""" + + +def do_setup(): + """Main VCS-independent setup function for installing Versioneer.""" + root = get_root() + try: + cfg = get_config_from_root(root) + except ( + EnvironmentError, + configparser.NoSectionError, + configparser.NoOptionError, + ) as e: + if isinstance(e, (EnvironmentError, configparser.NoSectionError)): + print( + "Adding sample versioneer config to setup.cfg", file=sys.stderr + ) + with open(os.path.join(root, "setup.cfg"), "a") as f: + f.write(SAMPLE_CONFIG) + print(CONFIG_ERROR, file=sys.stderr) + return 1 + + print(" creating %s" % cfg.versionfile_source) + with open(cfg.versionfile_source, "w") as f: + LONG = LONG_VERSION_PY[cfg.VCS] + f.write( + LONG + % { + "DOLLAR": "$", + "STYLE": cfg.style, + "TAG_PREFIX": cfg.tag_prefix, + "PARENTDIR_PREFIX": cfg.parentdir_prefix, + "VERSIONFILE_SOURCE": cfg.versionfile_source, + } + ) + + ipy = os.path.join(os.path.dirname(cfg.versionfile_source), "__init__.py") + if os.path.exists(ipy): + try: + with open(ipy, "r") as f: + old = f.read() + except EnvironmentError: + old = "" + if INIT_PY_SNIPPET not in old: + print(" appending to %s" % ipy) + with open(ipy, "a") as f: + f.write(INIT_PY_SNIPPET) + else: + print(" %s unmodified" % ipy) + else: + print(" %s doesn't exist, ok" % ipy) + ipy = None + + # Make sure both the top-level "versioneer.py" and versionfile_source + # (PKG/_version.py, used by runtime code) are in MANIFEST.in, so + # they'll be copied into source distributions. Pip won't be able to + # install the package without this. + manifest_in = os.path.join(root, "MANIFEST.in") + simple_includes = set() + try: + with open(manifest_in, "r") as f: + for line in f: + if line.startswith("include "): + for include in line.split()[1:]: + simple_includes.add(include) + except EnvironmentError: + pass + # That doesn't cover everything MANIFEST.in can do + # (http://docs.python.org/2/distutils/sourcedist.html#commands), so + # it might give some false negatives. Appending redundant 'include' + # lines is safe, though. + if "versioneer.py" not in simple_includes: + print(" appending 'versioneer.py' to MANIFEST.in") + with open(manifest_in, "a") as f: + f.write("include versioneer.py\n") + else: + print(" 'versioneer.py' already in MANIFEST.in") + if cfg.versionfile_source not in simple_includes: + print( + " appending versionfile_source ('%s') to MANIFEST.in" + % cfg.versionfile_source + ) + with open(manifest_in, "a") as f: + f.write("include %s\n" % cfg.versionfile_source) + else: + print(" versionfile_source already in MANIFEST.in") + + # Make VCS-specific changes. For git, this means creating/changing + # .gitattributes to mark _version.py for export-subst keyword + # substitution. + do_vcs_install(manifest_in, cfg.versionfile_source, ipy) + return 0 + + +def scan_setup_py(): + """Validate the contents of setup.py against Versioneer's expectations.""" + found = set() + setters = False + errors = 0 + with open("setup.py", "r") as f: + for line in f.readlines(): + if "import versioneer" in line: + found.add("import") + if "versioneer.get_cmdclass()" in line: + found.add("cmdclass") + if "versioneer.get_version()" in line: + found.add("get_version") + if "versioneer.VCS" in line: + setters = True + if "versioneer.versionfile_source" in line: + setters = True + if len(found) != 3: + print("") + print("Your setup.py appears to be missing some important items") + print("(but I might be wrong). Please make sure it has something") + print("roughly like the following:") + print("") + print(" import versioneer") + print(" setup( version=versioneer.get_version(),") + print(" cmdclass=versioneer.get_cmdclass(), ...)") + print("") + errors += 1 + if setters: + print("You should remove lines like 'versioneer.VCS = ' and") + print("'versioneer.versionfile_source = ' . This configuration") + print("now lives in setup.cfg, and should be removed from setup.py") + print("") + errors += 1 + return errors + + +if __name__ == "__main__": + cmd = sys.argv[1] + if cmd == "setup": + errors = do_setup() + errors += scan_setup_py() + if errors: + sys.exit(1)