FilesExpand file tree

master

/

release.py

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

executable file

·

123 lines (89 loc) · 3.16 KB

master

/

release.py

Copy path

Top

File metadata and controls

• Code
• Blame

executable file

·

123 lines (89 loc) · 3.16 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

#!/usr/bin/env python3

import argparse

import subprocess

import sys

from collections.abc import Iterable

from pathlib import Path

from shutil import which

class UsageError(Exception):

pass

def parse_version() -> str:

output = subprocess.check_output(["poetry", "version", "--short"], encoding="utf-8")

version = output.strip()

return version

def bump_version(path: Path, prefix_list: Iterable[str], current_version: str, new_version: str):

prefixes = tuple(prefix_list)

lines = []

for line in path.open():

if line.startswith(prefixes):

line = line.replace(current_version, new_version)

lines.append(line)

path.write_text("".join(lines))

def git(*args):

return subprocess.check_call(["git"] + list(args))

def make(*args):

return subprocess.check_call(["make"] + list(args))

def check_changelog():

old_changelog = Path("CHANGES.rst").read_text()

make("changes")

new_changelog = Path("CHANGES.rst").read_text()

if old_changelog == new_changelog:

raise UsageError("No new changelog entries")

def check_environment():

for binary in ("git", "make", "poetry"):

if not which(binary):

raise UsageError("No such binary: {}".format(binary))

def run_test_release():

return subprocess.check_call(["pytest", "tests/test_release.py", "--release"])

def check_git_repository_dirty():

result = subprocess.run(

[

"git",

"status",

"--porcelain",

"--ignored=matching",

],

capture_output=True,

encoding="utf-8",

check=False,

)

if result.returncode != 0:

raise UsageError("Failed to check git repository status")

accepted = [

"!! .venv/",

]

for line in result.stdout.splitlines():

if line not in accepted:

raise UsageError(

"Git repository is dirty. Please commit or stash changes before releasing, "

"or run git clean -fdx to remove ignored files."

)

def main() -> None:

parser = argparse.ArgumentParser()

parser.add_argument("new_version", help="Version to release")

args = parser.parse_args()

new_version: str = args.new_version

current_version = parse_version()

if current_version is None:

raise UsageError("Unable to parse version")

print(f"Current version: {current_version}")

if current_version == new_version:

raise UsageError("Current version is the same as new version")

check_git_repository_dirty()

check_changelog()

run_test_release()

bump_version(Path("doc/conf.py"), ["version"], current_version, new_version)

subprocess.check_call(["poetry", "version", new_version])

git("add", "pyproject.toml", "doc/conf.py")

git("commit", "-m", "Version bump to {}".format(new_version))

git("tag", new_version)

make("changes")

git("add", "CHANGES.rst")

git("commit", "-m", "CHANGES.rst: add release notes for {}".format(new_version))

git("tag", "-f", new_version)

if __name__ == "__main__":

try:

main()

except UsageError as err:

print(f"ERROR: {err}", file=sys.stderr)

sys.exit(1)