FilesExpand file tree

main

/

release.py

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

162 lines (131 loc) · 6.06 KB

main

/

release.py

Copy path

Top

File metadata and controls

• Code
• Blame

162 lines (131 loc) · 6.06 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

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

# coding=utf-8

# Copyright 2021 The HuggingFace Team. All rights reserved.

#

# Licensed under the Apache License, Version 2.0 (the "License");

# you may not use this file except in compliance with the License.

# You may obtain a copy of the License at

#

# http://www.apache.org/licenses/LICENSE-2.0

#

# Unless required by applicable law or agreed to in writing, software

# distributed under the License is distributed on an "AS IS" BASIS,

# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

# See the License for the specific language governing permissions and

# limitations under the License.

import argparse

import os

import re

import packaging.version

PATH_TO_EXAMPLES = "examples/"

REPLACE_PATTERNS = {

"examples": (re.compile(r'^check_min_version\("[^"]+"\)\s*$', re.MULTILINE), 'check_min_version("VERSION")\n'),

"init": (re.compile(r'^__version__\s+=\s+"([^"]+)"\s*$', re.MULTILINE), '__version__ = "VERSION"\n'),

"setup": (re.compile(r'^(\s*)version\s*=\s*"[^"]+",', re.MULTILINE), r'\1version="VERSION",'),

"doc": (re.compile(r'^(\s*)release\s*=\s*"[^"]+"$', re.MULTILINE), 'release = "VERSION"\n'),

}

REPLACE_FILES = {

"init": "src/diffusers/__init__.py",

"setup": "setup.py",

}

README_FILE = "README.md"

def update_version_in_file(fname, version, pattern):

"""Update the version in one file using a specific pattern."""

with open(fname, "r", encoding="utf-8", newline="\n") as f:

code = f.read()

re_pattern, replace = REPLACE_PATTERNS[pattern]

replace = replace.replace("VERSION", version)

code = re_pattern.sub(replace, code)

with open(fname, "w", encoding="utf-8", newline="\n") as f:

f.write(code)

def update_version_in_examples(version):

"""Update the version in all examples files."""

for folder, directories, fnames in os.walk(PATH_TO_EXAMPLES):

# Removing some of the folders with non-actively maintained examples from the walk

if "research_projects" in directories:

directories.remove("research_projects")

if "legacy" in directories:

directories.remove("legacy")

for fname in fnames:

if fname.endswith(".py"):

update_version_in_file(os.path.join(folder, fname), version, pattern="examples")

def global_version_update(version, patch=False):

"""Update the version in all needed files."""

for pattern, fname in REPLACE_FILES.items():

update_version_in_file(fname, version, pattern)

if not patch:

update_version_in_examples(version)

def clean_main_ref_in_model_list():

"""Replace the links from main doc tp stable doc in the model list of the README."""

# If the introduction or the conclusion of the list change, the prompts may need to be updated.

_start_prompt = "🤗 Transformers currently provides the following architectures"

_end_prompt = "1. Want to contribute a new model?"

with open(README_FILE, "r", encoding="utf-8", newline="\n") as f:

lines = f.readlines()

# Find the start of the list.

start_index = 0

while not lines[start_index].startswith(_start_prompt):

start_index += 1

start_index += 1

index = start_index

# Update the lines in the model list.

while not lines[index].startswith(_end_prompt):

if lines[index].startswith("1."):

lines[index] = lines[index].replace(

"https://huggingface.co/docs/diffusers/main/model_doc",

"https://huggingface.co/docs/diffusers/model_doc",

)

index += 1

with open(README_FILE, "w", encoding="utf-8", newline="\n") as f:

f.writelines(lines)

def get_version():

"""Reads the current version in the __init__."""

with open(REPLACE_FILES["init"], "r") as f:

code = f.read()

default_version = REPLACE_PATTERNS["init"][0].search(code).groups()[0]

return packaging.version.parse(default_version)

def pre_release_work(patch=False):

"""Do all the necessary pre-release steps."""

# First let's get the default version: base version if we are in dev, bump minor otherwise.

default_version = get_version()

if patch and default_version.is_devrelease:

raise ValueError("Can't create a patch version from the dev branch, checkout a released version!")

if default_version.is_devrelease:

default_version = default_version.base_version

elif patch:

default_version = f"{default_version.major}.{default_version.minor}.{default_version.micro + 1}"

else:

default_version = f"{default_version.major}.{default_version.minor + 1}.0"

# Now let's ask nicely if that's the right one.

version = input(f"Which version are you releasing? [{default_version}]")

if len(version) == 0:

version = default_version

print(f"Updating version to {version}.")

global_version_update(version, patch=patch)

# if not patch:

# print("Cleaning main README, don't forget to run `make fix-copies`.")

# clean_main_ref_in_model_list()

def post_release_work():

"""Do all the necesarry post-release steps."""

# First let's get the current version

current_version = get_version()

dev_version = f"{current_version.major}.{current_version.minor + 1}.0.dev0"

current_version = current_version.base_version

# Check with the user we got that right.

version = input(f"Which version are we developing now? [{dev_version}]")

if len(version) == 0:

version = dev_version

print(f"Updating version to {version}.")

global_version_update(version)

# print("Cleaning main README, don't forget to run `make fix-copies`.")

# clean_main_ref_in_model_list()

if __name__ == "__main__":

parser = argparse.ArgumentParser()

parser.add_argument("--post_release", action="store_true", help="Whether this is pre or post release.")

parser.add_argument("--patch", action="store_true", help="Whether or not this is a patch release.")

args = parser.parse_args()

if not args.post_release:

pre_release_work(patch=args.patch)

elif args.patch:

print("Nothing to do after a patch :-)")

else:

post_release_work()