#!/usr/bin/env python3
# This file is part of 'miniver': https://github.com/jbweston/miniver
import sys
import os
import os.path
import argparse
import tempfile
import shutil
import textwrap
import glob
from zipfile import ZipFile
from importlib.util import find_spec, spec_from_file_location, module_from_spec
from urllib.request import urlretrieve
if sys.version_info < (3, 5):
print("Miniver needs at least Python 3.5")
sys.exit(1)
try:
import miniver
_miniver_version = miniver.__version__
del miniver
_miniver_is_installed = True
except ImportError:
_miniver_version = "unknown"
_miniver_is_installed = False
# When we fetch miniver from local files
_miniver_modules = ("_version",)
# When we fetch miniver from GitHub
_miniver_zip_url = "https://github.com/jbweston/miniver/archive/master.zip"
_zipfile_root = "miniver-master" # tied to the fact that we fetch master.zip
# File templates
_setup_template = textwrap.dedent(
'''
def get_version_and_cmdclass(package_path):
"""Load version.py module without importing the whole package.
Template code from miniver
"""
import os
from importlib.util import module_from_spec, spec_from_file_location
spec = spec_from_file_location("version", os.path.join(package_path, "_version.py"))
module = module_from_spec(spec)
spec.loader.exec_module(module)
return module.__version__, module.cmdclass
version, cmdclass = get_version_and_cmdclass("{package_dir}")
setup(
...,
version=version,
cmdclass=cmdclass,
)
'''
)
_static_version_template = textwrap.dedent(
"""\
# -*- coding: utf-8 -*-
# This file is part of 'miniver': https://github.com/jbweston/miniver
#
# This file will be overwritten by setup.py when a source or binary
# distribution is made. The magic value "__use_git__" is interpreted by
# version.py.
version = "__use_git__"
# These values are only set if the distribution was created with 'git archive'
refnames = "$Format:%D$"
git_hash = "$Format:%h$"
"""
)
_init_template = "from ._version import __version__"
_gitattribute_template = "{package_dir}/_static_version.py export-subst"
def _line_in_file(to_find, filename):
"""Return True if the specified line exists in the named file."""
assert "\n" not in to_find
try:
with open(filename) as f:
for line in f:
if to_find in line:
return True
return False
except FileNotFoundError:
return False
def _write_line(content, filename):
assert "\n" not in content
if not _line_in_file(content, filename):
with open(filename, "a") as f:
f.write(content)
def _write_content(content, filename):
with open(filename, "w") as f:
f.write(content)
def _fail(msg):
print(msg, file=sys.stderr)
print("Miniver was not installed", file=sys.stderr)
sys.exit(1)
def extract_miniver_from_github():
filename, _ = urlretrieve(_miniver_zip_url)
z = ZipFile(filename)
tmpdir = tempfile.mkdtemp()
input_paths = [
"/".join((_zipfile_root, "miniver", module + ".py"))
for module in _miniver_modules
]
for p in input_paths:
z.extract(p, path=tmpdir)
return [os.path.join(tmpdir, *p.split()) for p in input_paths]
def extract_miniver_from_local():
return [
find_spec("." + module, package="miniver").origin for module in _miniver_modules
]
def get_parser():
parser = argparse.ArgumentParser(description="Interact with miniver")
parser.add_argument("-v", "--version", action="version", version=_miniver_version)
# TODO: when we can depend on Python 3.7 make this "add_subparsers(required=True)"
subparsers = parser.add_subparsers()
# 'install' command
install_parser = subparsers.add_parser(
"install", help="Install miniver into the current Python package"
)
install_parser.add_argument(
"package_directory", help="Directory to install 'miniver' into."
)
install_parser.set_defaults(dispatch=install)
# 'ver' command
ver_parser = subparsers.add_parser(
"ver", help="Get generated version"
)
ver_parser.add_argument(
"package_directory", help="Directory 'miniver' was installed."
)
ver_parser.set_defaults(dispatch=ver)
return parser
def install(args):
package_dir = args.package_directory
if not os.path.isdir(package_dir):
_fail("Directory '{}' does not exist".format(package_dir))
if package_dir != os.path.relpath(package_dir):
_fail("'{}' is not a relative directory".format(package_dir))
# Get miniver files
if _miniver_is_installed:
miniver_paths = extract_miniver_from_local()
else:
miniver_paths = extract_miniver_from_github()
output_paths = [
os.path.join(package_dir, os.path.basename(path)) for path in miniver_paths
]
for path in output_paths:
if os.path.exists(path):
_fail("'{}' already exists".format(path))
# Write content to local package directory
for path, output_path in zip(miniver_paths, output_paths):
shutil.copy(path, output_path)
_write_content(
_static_version_template, os.path.join(package_dir, "_static_version.py")
)
_write_line(
_gitattribute_template.format(package_dir=package_dir), ".gitattributes"
)
_write_line(
_init_template.format(package_dir=package_dir),
os.path.join(package_dir, "__init__.py"),
)
msg = "\n".join(
textwrap.wrap(
"Miniver is installed into '{package_dir}/'. "
"You still have to copy the following snippet into your 'setup.py':"
)
)
print("\n".join((msg, _setup_template)).format(package_dir=package_dir))
def ver(args):
package_dir = args.package_directory
try:
version_location, = glob.glob(f"{package_dir}/**/_version.py", recursive=True)
except ValueError as err:
if "not enough" in str(err):
print(f"'_version.py' not found in '{package_dir}'", file=sys.stderr)
sys.exit(1)
elif "too many" in str(err):
print(f"More than 1 '_version.py' found in '{package_dir}'", file=sys.stderr)
sys.exit(1)
else:
raise
version_spec = spec_from_file_location("version", version_location)
version = module_from_spec(version_spec)
version_spec.loader.exec_module(version)
print(version.get_version())
def main():
parser = get_parser()
args = parser.parse_args()
# TODO: remove this check when we can rely on Python 3.7 and
# can make subparsers required.
if "dispatch" in args:
args.dispatch(args)
else:
parser.parse_args(["-h"])
if __name__ == "__main__":
main()