


'''simple docstring'''


import argparse
import os
import re

import packaging.version


lowerCamelCase__    	=     'examples/'
lowerCamelCase__    	=     {
    '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'),
}
lowerCamelCase__    	=     {
    'init': 'src/transformers/__init__.py',
    'setup': 'setup.py',
}
lowerCamelCase__    	=     'README.md'






def  __lowerCAmelCase (__lowerCAmelCase      , __lowerCAmelCase      , __lowerCAmelCase   ):
		with open(__lowerCAmelCase      , "r"      , encoding="utf-8"      , newline="\n"   ) as f:
				_UpperCAmelCase		:       Optional[int]								=      f.read()
		_UpperCAmelCase					,    _UpperCAmelCase		:       Optional[Any]								=      REPLACE_PATTERNS[pattern]
		_UpperCAmelCase		:       Tuple								=      replace.replace("VERSION"      , __lowerCAmelCase   )
		_UpperCAmelCase		:       Optional[Any]								=      re_pattern.sub(__lowerCAmelCase      , __lowerCAmelCase   )
		with open(__lowerCAmelCase      , "w"      , encoding="utf-8"      , newline="\n"   ) as f:
				f.write(__lowerCAmelCase   )






def  __lowerCAmelCase (__lowerCAmelCase   ):
		for folder, directories, fnames in os.walk(__lowerCAmelCase   ):
				# 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(__lowerCAmelCase      , __lowerCAmelCase   )      , __lowerCAmelCase      , pattern="examples"   )






def  __lowerCAmelCase (__lowerCAmelCase      , __lowerCAmelCase=False   ):
		for pattern, fname in REPLACE_FILES.items():
				update_version_in_file(__lowerCAmelCase      , __lowerCAmelCase      , __lowerCAmelCase   )
		if not patch:
				update_version_in_examples(__lowerCAmelCase   )






def  __lowerCAmelCase ():
		_UpperCAmelCase		:       Optional[int]								=      "🤗 Transformers currently provides the following architectures"
		_UpperCAmelCase		:       Any								=      "1. Want to contribute a new model?"
		with open(__lowerCAmelCase      , "r"      , encoding="utf-8"      , newline="\n"   ) as f:
				_UpperCAmelCase		:       Union[str, Any]								=      f.readlines()

		# Find the start of the list.
		_UpperCAmelCase		:       Optional[Any]								=      0
		while not lines[start_index].startswith(_start_prompt   ):
				start_index += 1
		start_index += 1

		_UpperCAmelCase		:       Dict								=      start_index
		# Update the lines in the model list.
		while not lines[index].startswith(_end_prompt   ):
				if lines[index].startswith("1."   ):
						_UpperCAmelCase		:       Tuple								=      lines[index].replace(
						    "https://huggingface.co/docs/transformers/main/model_doc"      , "https://huggingface.co/docs/transformers/model_doc"      , )
				index += 1

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






def  __lowerCAmelCase ():
		with open(REPLACE_FILES["init"]      , "r"   ) as f:
				_UpperCAmelCase		:       Dict								=      f.read()
		_UpperCAmelCase		:       List[str]								=      REPLACE_PATTERNS["init"][0].search(__lowerCAmelCase   ).groups()[0]
		return packaging.version.parse(__lowerCAmelCase   )






def  __lowerCAmelCase (__lowerCAmelCase=False   ):
		_UpperCAmelCase		:       str								=      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:
				_UpperCAmelCase		:       int								=      default_version.base_version
		elif patch:
				_UpperCAmelCase		:       List[Any]								=      F"""{default_version.major}.{default_version.minor}.{default_version.micro + 1}"""
		else:
				_UpperCAmelCase		:       str								=      F"""{default_version.major}.{default_version.minor + 1}.0"""

		# Now let's ask nicely if that's the right one.
		_UpperCAmelCase		:       Optional[Any]								=      input(F"""Which version are you releasing? [{default_version}]"""   )
		if len(__lowerCAmelCase   ) == 0:
				_UpperCAmelCase		:       List[str]								=      default_version

		print(F"""Updating version to {version}."""   )
		global_version_update(__lowerCAmelCase      , patch=__lowerCAmelCase   )
		if not patch:
				print("Cleaning main README, don't forget to run `make fix-copies`."   )
				clean_main_ref_in_model_list()






def  __lowerCAmelCase ():
		_UpperCAmelCase		:       Tuple								=      get_version()
		_UpperCAmelCase		:       Tuple								=      F"""{current_version.major}.{current_version.minor + 1}.0.dev0"""
		_UpperCAmelCase		:       Union[str, Any]								=      current_version.base_version

		# Check with the user we got that right.
		_UpperCAmelCase		:       str								=      input(F"""Which version are we developing now? [{dev_version}]"""   )
		if len(__lowerCAmelCase   ) == 0:
				_UpperCAmelCase		:       Optional[Any]								=      dev_version

		print(F"""Updating version to {version}."""   )
		global_version_update(__lowerCAmelCase   )
		print("Cleaning main README, don't forget to run `make fix-copies`."   )
		clean_main_ref_in_model_list()


if __name__ == "__main__":
						lowerCamelCase__    	=     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.')
						lowerCamelCase__    	=     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()







'''simple docstring'''


def  __lowerCAmelCase ():
		_UpperCAmelCase		:       str								=      0
		for i in range(1      , 1_001   ):
				total += i**i
		return str(__lowerCAmelCase   )[-10:]


if __name__ == "__main__":
						print(solution())



