cmd/pypi_release.py

421 lines
12 KiB
Python
Raw Normal View History

import argparse
import re
import shutil
import subprocess
import sys
import textwrap
import time
from voussoirkit import passwordy
from voussoirkit import winwhich
GIT = winwhich.which('git')
PY = winwhich.which('py')
TWINE = winwhich.which('twine')
BUMP_PATTERN = r'Bump to version (\d+\.\d+\.\d+)\.'
DEBUG = False
class PypiReleaseError(Exception):
pass
class BadSetup(PypiReleaseError):
pass
class DirtyState(PypiReleaseError):
pass
class NotSemver(PypiReleaseError):
pass
class VersionOutOfOrder(PypiReleaseError):
pass
# HELPER FUNCTIONS
################################################################################
def bump_version(version, versionbump):
(major, minor, patch) = [int(x) for x in version.split('.')]
if versionbump == 'major':
major += 1
minor = 0
patch = 0
elif versionbump == 'minor':
minor += 1
patch = 0
elif versionbump == 'patch':
patch += 1
else:
raise ValueError(f'versionbump should be major, minor, or patch, not {versionbump}.')
version = f'{major}.{minor}.{patch}'
return version
def check_call(command, show_command=True):
if DEBUG or show_command:
print_command(command)
return subprocess.check_call(command)
def check_output(command, show_command=True):
if DEBUG or show_command:
print_command(command)
return subprocess.check_output(command, stderr=subprocess.STDOUT)
def pick_versionbump(major, minor, patch):
mmp = (major, minor, patch)
if not all(b in [True, False, None] for b in mmp):
raise TypeError('major, minor, patch should all be True, False, or None.')
if mmp in [(False, False, False), (None, None, None)]:
versionbump = 'patch'
elif mmp.count(True) > 1:
raise TypeError('Must only pick one of major, minor, patch.')
elif major:
versionbump = 'major'
elif minor:
versionbump = 'minor'
elif patch:
versionbump = 'patch'
else:
raise TypeError()
return versionbump
def print_command(command):
cmd = [('"%s"' % x) if (' ' in x or x == '') else x for x in command]
cmd = ' '.join(cmd)
cmd = cmd.strip()
cmd = cmd.replace(GIT, 'git')
cmd = cmd.replace(PY, 'py')
cmd = cmd.replace(TWINE, 'twine')
print(f'> {cmd}')
def semver_split(semver):
original = semver
try:
semver = semver.strip('v')
mmp = semver.split('.')
mmp = tuple(int(x) for x in mmp)
(major, minor, patch) = mmp
return mmp
except Exception:
raise NotSemver(original)
def slowprint(s=None):
slow = 0.05
if s is None:
print()
time.sleep(slow)
return
for line in s.split('\n'):
print(line)
time.sleep(slow)
# SETUP.PY
################################################################################
def extract_info_from_setup():
handle = open('setup.py', 'r', encoding='utf-8')
with handle:
setup_py = handle.read()
name = re.findall(r'''\bname=["']([A-Za-z0-9_-]+)["']''', setup_py)
if len(name) != 1:
raise BadSetup(f'Expected to find 1 name but found {len(name)}.')
name = name[0]
version = re.findall(r'''\bversion=["'](\d+\.\d+\.\d+)["']''', setup_py)
if len(version) != 1:
raise BadSetup(f'Expected to find 1 version but found {len(version)}.')
version = version[0]
return (setup_py, name, version)
def update_info_in_setup(setup_py, name, version):
re_from = fr'''\bname=(["'])({name})(["'])'''
re_to = fr'''name=\1\2\3'''
setup_py = re.sub(re_from, re_to, setup_py)
re_from = fr'''\bversion=(["'])(\d+\.\d+\.\d+)(["'])'''
re_to = fr'''version=\g<1>{version}\g<3>'''
setup_py = re.sub(re_from, re_to, setup_py)
return setup_py
def write_setup(setup_py):
handle = open('setup.py', 'w', encoding='utf-8')
with handle:
handle.write(setup_py)
# GIT
################################################################################
def git_assert_current_greater_than_latest(latest_release_version, new_version):
if latest_release_version >= semver_split(new_version):
raise VersionOutOfOrder(f'New version should be {new_version} but {latest_release_version} already exists.')
def git_assert_no_stashes():
command = [GIT, 'stash', 'list']
output = check_output(command, show_command=False)
lines = output.strip().splitlines()
if len(lines) != 0:
raise DirtyState('Please ensure there are no stashes.')
def git_assert_pushable():
command = [GIT, 'fetch', '--all']
check_output(command, show_command=False)
command = [GIT, 'merge-base', '@', '@{u}']
merge_base = check_output(command, show_command=False).strip()
command = [GIT, 'rev-parse', '@']
my_head = check_output(command, show_command=False).strip()
command = [GIT, 'rev-parse', '@{u}']
remote_head = check_output(command, show_command=False).strip()
if my_head == remote_head:
pass
elif my_head == merge_base:
git_commits_since(merge_base.decode(), show=True, inclusive=True)
raise DirtyState('Cant push, need to pull first.')
elif remote_head == merge_base:
pass
else:
git_commits_since(merge_base.decode(), show=True, inclusive=True)
raise DirtyState('Cant push, diverged from remote.')
def git_commit_bump(version):
command = [GIT, 'add', 'setup.py']
check_output(command)
command = [GIT, 'commit', '-m', f'Bump to version {version}.']
check_output(command)
def git_commits_since(commit, show, inclusive=False):
if commit:
if inclusive:
commit += '~1'
command = [GIT, '--no-pager', 'log', '--oneline', '--graph', '--branches', '--remotes', f'{commit}..']
else:
command = [GIT, '--no-pager', 'log', '--oneline', '--graph']
if show:
check_call(command, show_command=False)
else:
output = check_output(command, show_command=False)
lines = output.strip().splitlines()
return lines
def git_current_remote_branch():
command = [GIT, 'rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{u}']
output = check_output(command, show_command=False)
output = output.strip().decode()
(remote, branch) = output.split('/')
return (remote, branch)
def git_determine_latest_release():
(latest_tagged_commit, latest_tag_version) = git_latest_tagged_commit()
(latest_bump_commit, latest_bump_version) = git_latest_bump_commit()
if latest_tagged_commit is None:
latest_release_commit = latest_bump_commit
latest_release_version = latest_bump_version
elif latest_bump_commit is None:
latest_release_commit = latest_tagged_commit
latest_release_version = latest_tag_version
elif latest_tag_version > latest_bump_version:
latest_release_commit = latest_tagged_commit
latest_release_version = latest_tag_version
else:
latest_release_commit = latest_bump_commit
latest_release_version = latest_bump_version
return (latest_release_commit, latest_release_version)
def git_latest_bump_commit():
command = [GIT, 'log', '--oneline', '--no-abbrev-commit', '--grep', 'Bump to version *.', '-1']
output = check_output(command, show_command=False)
output = output.strip()
if not output:
return (None, None)
commit = output.splitlines()[0].decode()
version = re.search(BUMP_PATTERN, commit).group(1)
version = semver_split(version)
commit = commit.split()[0]
return (commit, version)
def git_latest_tagged_commit():
command = [GIT, 'log', '--oneline', '--no-abbrev-commit', '--tags=v*.*.*', '-1']
output = check_output(command, show_command=False)
output = output.strip()
if not output:
return (None, None)
commit = output.splitlines()[0].decode().split()[0]
for tag in git_tags_on_commit(commit):
try:
version = semver_split(tag)
break
except NotSemver:
pass
else:
return (None, None)
return (commit, version)
def git_push(remote, branch):
command = [GIT, 'push', remote, branch]
check_output(command)
def git_push_tag(remote, tag):
command = [GIT, 'push', remote, tag]
check_output(command)
def git_show_commit(commit):
command = [GIT, 'show', '--oneline', '-s', commit]
check_call(command, show_command=False)
def git_stash_push():
token = passwordy.urandom_hex(32)
command = [GIT, 'stash', 'push', '--include-untracked', '--message', token]
output = check_output(command)
command = [GIT, 'stash', 'list', '--grep', token]
output = check_output(command).strip()
did_stash = bool(output)
return did_stash
def git_stash_restore():
command = [GIT, 'stash', 'pop']
output = check_output(command)
def git_tag_version(tag):
command = [GIT, 'tag', '-a', tag, '-m', '']
check_output(command)
def git_tags_on_commit(commit):
command = [GIT, 'tag', '--points-at', commit]
output = check_output(command, show_command=False)
output = output.strip()
if not output:
return []
output = output.decode().splitlines()
return output
# PYPI
################################################################################
def pypi_upload(name):
egg_dir = f'{name}.egg-info'
command = [PY, 'setup.py', 'sdist']
check_output(command)
command = [TWINE, 'upload', '-r', 'pypi', 'dist\\*']
check_output(command)
shutil.rmtree('dist')
shutil.rmtree(egg_dir)
def pypi_release(do_tag=False, versionbump='patch'):
git_assert_no_stashes()
git_assert_pushable()
(setup_py, name, old_version) = extract_info_from_setup()
new_version = bump_version(old_version, versionbump)
new_tag = f'v{new_version}'
(latest_release_commit, latest_release_version) = git_determine_latest_release()
git_assert_current_greater_than_latest(latest_release_version, new_version)
commits_since_last_release = git_commits_since(latest_release_commit, show=False)
if len(commits_since_last_release) == 0:
print('No new commits to release')
return
(remote, branch) = git_current_remote_branch()
def linebreak():
cli_width = shutil.get_terminal_size()[0]
line = '#' * (cli_width - 1)
line += '\r'
line += f'# {name} {new_version} '
line = f'\n{line}\n'
slowprint(line)
linebreak()
slowprint(f'Upgrading {name} from {old_version} --> {new_version}.')
slowprint()
if latest_release_commit:
slowprint('Latest release:')
git_show_commit(latest_release_commit)
slowprint()
slowprint('This release:')
git_commits_since(latest_release_commit, show=True)
slowprint()
setup_py = update_info_in_setup(setup_py, name, new_version)
slowprint('Rewrite setup.py:')
slowprint(textwrap.indent(setup_py, '>>> '))
slowprint()
slowprint(f'Release will be pushed to {remote} {branch}.')
linebreak()
input(f'PRESS ENTER TO RELEASE {name} {new_version}.')
write_setup(setup_py)
git_commit_bump(new_version)
if do_tag:
git_tag_version(new_tag)
git_push(remote, branch)
if do_tag:
git_push_tag(remote, new_tag)
did_stash = git_stash_push()
pypi_upload(name)
if did_stash:
git_stash_restore()
git_commits_since(latest_release_commit, show=True)
def pypi_release_argparse(args):
global DEBUG
if args.debug:
DEBUG = True
versionbump = pick_versionbump(args.major, args.minor, args.patch)
try:
return pypi_release(do_tag=args.do_tag, versionbump=versionbump)
except subprocess.CalledProcessError as exc:
print(exc.output)
return 1
def main(argv):
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('--major', dest='major', action='store_true')
parser.add_argument('--minor', dest='minor', action='store_true')
parser.add_argument('--patch', dest='patch', action='store_true')
parser.add_argument('--do_tag', dest='do_tag', action='store_true')
parser.add_argument('--debug', dest='debug', action='store_true')
parser.set_defaults(func=pypi_release_argparse)
args = parser.parse_args(argv)
return args.func(args)
if __name__ == '__main__':
raise SystemExit(main(sys.argv[1:]))