use versioneer for versioning

.gitattributes

@@ -0,0 +1 @@
+pyvirtualdisplay/_version.py export-subst

.gitignore

@@ -25,8 +25,12 @@ nosetests.xml
 
 .*
 !.gitignore
+!.gitattributes
+
 /distribute_setup.py
 
 
 sloccount.sc
 *.prefs
+
+MANIFEST

MANIFEST.in

@@ -3,6 +3,7 @@ include LICENSE*
 include pavement.py
 include TODO*
 include requirements.txt
+include versioneer.py
 include CHANGES*
 include README*
 include setup.py

docs/conf.py

@@ -1,24 +1,10 @@
-from path import path
-from setuptools import find_packages
+from easyprocess import EasyProcess
 import logging
-import sphinx
-import sys
 
 
-def read_project_version(py=None, where='.', exclude=['bootstrap', 'pavement', 'doc', 'docs', 'test', 'tests', ]):
-    if not py:
-        py = path(where) / find_packages(where=where, exclude=exclude)[0]
-    py = path(py)
-    if py.isdir():
-        py = py / '__init__.py'
-    __version__ = None
-    for line in py.lines():
-        if '__version__' in line:
-            exec line
-            break
-    return __version__
-
-release = read_project_version(where='..')
+p = EasyProcess('python setup.py --version', cwd='..').call()
+release = p.stdout.splitlines()[-1]
+print release
 
 project = 'PyVirtualDisplay'
 author = 'ponty'

pavement.py

@@ -13,9 +13,11 @@
 from paved.pkg import *
 
 # get info from setup.py
+sys.path.append('.')
 setup_py = ''.join(
-    [x for x in path('setup.py').lines() if 'setuptools' not in x])
+    [x for x in path('setup.py').lines() if 'distutils' not in x])
 exec(setup_py)
+sys.path.pop()
 
 
 options(
@@ -47,6 +49,7 @@
 options.paved.dist.manifest.include.remove('distribute_setup.py')
 options.paved.dist.manifest.include.remove('paver-minilib.zip')
 options.paved.dist.manifest.include.add('requirements.txt')
+options.paved.dist.manifest.include.add('versioneer.py')
 
 
 @task
@@ -64,7 +67,9 @@ def alltest():
 
 
 @task
-@needs('manifest', 'setuptools.command.sdist')
+@needs('manifest',
+       'distutils.command.sdist',
+       )
 def sdist():
     """Overrides sdist to make sure that our MANIFEST.in is generated.
     """

pyvirtualdisplay/__init__.py

@@ -1,7 +1,10 @@
 from display import Display
 import logging
 
-__version__ = '0.1.3'
-
 log = logging.getLogger(__name__)
+
+from ._version import get_versions
+__version__ = get_versions()['version']
+del get_versions
+
 log.debug('version=' + __version__)

pyvirtualdisplay/_version.py

@@ -0,0 +1,188 @@
+
+# This file helps to compute a version number in source trees obtained from
+# git-archive tarball (such as those provided by githubs download-from-tag
+# feature). Distribution tarballs (build by setup.py sdist) and build
+# directories (produced by setup.py build) will contain a much shorter file
+# that just contains the computed version number.
+
+# This file is released into the public domain. Generated by
+# versioneer-0.10 (https://github.com/warner/python-versioneer)
+
+# these strings will be replaced by git during git-archive
+git_refnames = "$Format:%d$"
+git_full = "$Format:%H$"
+
+
+import subprocess
+import sys
+import errno
+
+
+def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False):
+    assert isinstance(commands, list)
+    p = None
+    for c in commands:
+        try:
+            # remember shell=False, so use git.cmd on windows, not just git
+            p = subprocess.Popen([c] + args, cwd=cwd, 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" % args[0])
+                print(e)
+            return None
+    else:
+        if verbose:
+            print("unable to find command, tried %s" % (commands,))
+        return None
+    stdout = p.communicate()[0].strip()
+    if sys.version >= '3':
+        stdout = stdout.decode()
+    if p.returncode != 0:
+        if verbose:
+            print("unable to run %s (error)" % args[0])
+        return None
+    return stdout
+
+
+import sys
+import re
+import os.path
+
+def get_expanded_variables(versionfile_abs):
+    # the code embedded in _version.py can just fetch the value of these
+    # variables. When used from setup.py, we don't want to import
+    # _version.py, so we do it with a regexp instead. This function is not
+    # used from _version.py.
+    variables = {}
+    try:
+        f = open(versionfile_abs,"r")
+        for line in f.readlines():
+            if line.strip().startswith("git_refnames ="):
+                mo = re.search(r'=\s*"(.*)"', line)
+                if mo:
+                    variables["refnames"] = mo.group(1)
+            if line.strip().startswith("git_full ="):
+                mo = re.search(r'=\s*"(.*)"', line)
+                if mo:
+                    variables["full"] = mo.group(1)
+        f.close()
+    except EnvironmentError:
+        pass
+    return variables
+
+def versions_from_expanded_variables(variables, tag_prefix, verbose=False):
+    refnames = variables["refnames"].strip()
+    if refnames.startswith("$Format"):
+        if verbose:
+            print("variables are unexpanded, not using")
+        return {} # unexpanded, so not in an unpacked git-archive tarball
+    refs = set([r.strip() for r in refnames.strip("()").split(",")])
+    # 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": variables["full"].strip() }
+    # no suitable tags, so we use the full revision id
+    if verbose:
+        print("no suitable tags, using full revision id")
+    return { "version": variables["full"].strip(),
+             "full": variables["full"].strip() }
+
+def versions_from_vcs(tag_prefix, root, verbose=False):
+    # this runs 'git' from the root of the source tree. This only gets called
+    # if the git-archive 'subst' variables were *not* expanded, and
+    # _version.py hasn't already been rewritten with a short version string,
+    # meaning we're inside a checked out source tree.
+
+    if not os.path.exists(os.path.join(root, ".git")):
+        if verbose:
+            print("no .git in %s" % root)
+        return {}
+
+    GITS = ["git"]
+    if sys.platform == "win32":
+        GITS = ["git.cmd", "git.exe"]
+    stdout = run_command(GITS, ["describe", "--tags", "--dirty", "--always"],
+                         cwd=root)
+    if stdout is None:
+        return {}
+    if not stdout.startswith(tag_prefix):
+        if verbose:
+            print("tag '%s' doesn't start with prefix '%s'" % (stdout, tag_prefix))
+        return {}
+    tag = stdout[len(tag_prefix):]
+    stdout = run_command(GITS, ["rev-parse", "HEAD"], cwd=root)
+    if stdout is None:
+        return {}
+    full = stdout.strip()
+    if tag.endswith("-dirty"):
+        full += "-dirty"
+    return {"version": tag, "full": full}
+
+
+def versions_from_parentdir(parentdir_prefix, root, verbose=False):
+    # Source tarballs conventionally unpack into a directory that includes
+    # both the project name and a version string.
+    dirname = os.path.basename(root)
+    if not dirname.startswith(parentdir_prefix):
+        if verbose:
+            print("guessing rootdir is '%s', but '%s' doesn't start with prefix '%s'" %
+                  (root, dirname, parentdir_prefix))
+        return None
+    return {"version": dirname[len(parentdir_prefix):], "full": ""}
+
+tag_prefix = ""
+parentdir_prefix = "pyvirtualdisplay-"
+versionfile_source = "pyvirtualdisplay/_version.py"
+
+def get_versions(default={"version": "unknown", "full": ""}, verbose=False):
+    # 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 variables.
+
+    variables = { "refnames": git_refnames, "full": git_full }
+    ver = versions_from_expanded_variables(variables, tag_prefix, verbose)
+    if ver:
+        return ver
+
+    try:
+        root = os.path.abspath(__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 range(len(versionfile_source.split("/"))):
+            root = os.path.dirname(root)
+    except NameError:
+        return default
+
+    return (versions_from_vcs(tag_prefix, root, verbose)
+            or versions_from_parentdir(parentdir_prefix, root, verbose)
+            or default)
+

setup.py

@@ -1,22 +1,20 @@
-from setuptools import find_packages, setup
+import versioneer
+from distutils.core import setup
 import os.path
 import sys
 
 
-def read_project_version(package):
-    py = os.path.join(package, '__init__.py')
-    __version__ = None
-    for line in open(py).read().splitlines():
-        if '__version__' in line:
-            exec(line)
-            break
-    return __version__
-
-PACKAGE = 'pyvirtualdisplay'
-NAME = 'PyVirtualDisplay'
+NAME = 'pyvirtualdisplay'
 URL = 'https://github.com/ponty/PyVirtualDisplay'
 DESCRIPTION = 'python wrapper for Xvfb, Xephyr and Xvnc'
-VERSION = read_project_version(PACKAGE)
+PACKAGES = [NAME,
+            NAME + '.examples',
+            ]
+
+versioneer.versionfile_source = NAME + '/_version.py'
+versioneer.versionfile_build = versioneer.versionfile_source
+versioneer.tag_prefix = ''
+versioneer.parentdir_prefix = NAME + '-'
 
 extra = {}
 if sys.version_info >= (3,):
@@ -33,10 +31,10 @@ def read_project_version(package):
 
 install_requires = open("requirements.txt").read().split('\n')
 
-# compatible with distutils of python 2.3+ or later
 setup(
     name=NAME,
-    version=VERSION,
+    version=versioneer.get_version(),
+    cmdclass=versioneer.get_cmdclass(),
     description=DESCRIPTION,
     long_description=open('README.rst', 'r').read(),
     classifiers=classifiers,
@@ -45,10 +43,7 @@ def read_project_version(package):
     # author_email='',
     url=URL,
     license='BSD',
-    packages=find_packages(exclude=['bootstrap', 'pavement', ]),
-    include_package_data=True,
-    test_suite='nose.collector',
-    zip_safe=False,
+    packages=PACKAGES,
     install_requires=install_requires,
     **extra
 )