




import argparse
import os
import re

import packaging.version


_lowerCamelCase      :  List[Any]      						=						'''examples/'''
_lowerCamelCase      :  int      						=						{
    '''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      :  int      						=						{
    '''init''': '''src/transformers/__init__.py''',
    '''setup''': '''setup.py''',
}
_lowerCamelCase      :  Any      						=						'''README.md'''




def 							_UpperCAmelCase  (UpperCamelCase_ : str      ,    UpperCamelCase_ : int      ,    UpperCamelCase_ : Union[str, Any]       ):
				'''simple docstring'''

				with open(_A      ,    """r"""      ,    encoding="""utf-8"""      ,    newline="""\n"""       ) as f:
								_lowerCAmelCase										=      f.read()
				_lowerCAmelCase					,    _lowerCAmelCase										=      REPLACE_PATTERNS[pattern]
				_lowerCAmelCase										=      replace.replace("""VERSION"""      ,    _A       )
				_lowerCAmelCase										=      re_pattern.sub(_A      ,    _A       )
				with open(_A      ,    """w"""      ,    encoding="""utf-8"""      ,    newline="""\n"""       ) as f:
								f.write(_A       )




def 							_UpperCAmelCase  (UpperCamelCase_ : str       ):
				'''simple docstring'''

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




def 							_UpperCAmelCase  (UpperCamelCase_ : Dict      ,    UpperCamelCase_ : List[Any]=False       ):
				'''simple docstring'''

				for pattern, fname in REPLACE_FILES.items():
								update_version_in_file(_A      ,    _A      ,    _A       )
				if not patch:
								update_version_in_examples(_A       )




def 							_UpperCAmelCase  ():
				'''simple docstring'''
				_lowerCAmelCase										=      """🤗 Transformers currently provides the following architectures"""
				_lowerCAmelCase										=      """1. Want to contribute a new model?"""
				with open(_A      ,    """r"""      ,    encoding="""utf-8"""      ,    newline="""\n"""       ) as f:
								_lowerCAmelCase										=      f.readlines()

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

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

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




def 							_UpperCAmelCase  ():
				'''simple docstring'''

				with open(REPLACE_FILES["""init"""]      ,    """r"""       ) as f:
								_lowerCAmelCase										=      f.read()
				_lowerCAmelCase										=      REPLACE_PATTERNS["""init"""][0].search(_A       ).groups()[0]
				return packaging.version.parse(_A       )




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

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

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




def 							_UpperCAmelCase  ():
				'''simple docstring'''
				_lowerCAmelCase										=      get_version()
				_lowerCAmelCase										=      F"{current_version.major}.{current_version.minor + 1}.0.dev0"
				_lowerCAmelCase										=      current_version.base_version

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

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


if __name__ == "__main__":
	_lowerCamelCase      :  str      						=						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      :  int      						=						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()







import numpy as np




def 							_UpperCAmelCase  (UpperCamelCase_ : np.array       ):
				'''simple docstring'''
				return (2 / (1 + np.exp(-2 * vector       ))) - 1


if __name__ == "__main__":
	import doctest

	doctest.testmod()

