"""Get the project root directory.

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

"""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.ConfigParser()

with open(setup_cfg, "r") as f:

parser.read_file(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")

"""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

env=None):

"""Call the given command(s)."""

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, 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", [c] + args)

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

"""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

"""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