

'''simple docstring'''



import argparse
import os
import re

import packaging.version


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






						"""simple docstring"""





						with open(__snake_case,		"""r""",		encoding="""utf-8""",		newline="""\n"""	) as f:
												A__					:       List[Any]     =f.read()
						A__					:       str     =REPLACE_PATTERNS[pattern]
						A__					:       Dict     =replace.replace("""VERSION""",		__snake_case	)
						A__					:       Optional[int]     =re_pattern.sub(__snake_case,		__snake_case	)
						with open(__snake_case,		"""w""",		encoding="""utf-8""",		newline="""\n"""	) as f:
												f.write(__snake_case	)
def 						__lowerCamelCase	(       __snake_case					:		Union[str, Any]	):






						"""simple docstring"""





						for folder, directories, fnames in os.walk(__snake_case	):
												# 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(__snake_case,		__snake_case	),		__snake_case,		pattern="""examples"""	)
def 						__lowerCamelCase	(       __snake_case					:		List[Any],		__snake_case					:		Optional[int]=False	):






						"""simple docstring"""





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






						"""simple docstring"""





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

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

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

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






						"""simple docstring"""





						with open(REPLACE_FILES["""init"""],		"""r"""	) as f:
												A__					:       Tuple     =f.read()
						A__					:       List[Any]     =REPLACE_PATTERNS["""init"""][0].search(__snake_case	).groups()[0]
						return packaging.version.parse(__snake_case	)
def 						__lowerCamelCase	(       __snake_case					:		Tuple=False	):






						"""simple docstring"""





						A__					:       Tuple     =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:
												A__					:       Optional[int]     =default_version.base_version
						elif patch:
												A__					:       Optional[int]     =f"{default_version.major}.{default_version.minor}.{default_version.micro + 1}"
						else:
												A__					:       List[str]     =f"{default_version.major}.{default_version.minor + 1}.0"

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

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






						"""simple docstring"""





						A__					:       Any     =get_version()
						A__					:       Optional[int]     =f"{current_version.major}.{current_version.minor + 1}.0.dev0"
						A__					:       str     =current_version.base_version

						# Check with the user we got that right.
						A__					:       Dict     =input(f"Which version are we developing now? [{dev_version}]"	)
						if len(__snake_case	) == 0:
												A__					:       str     =dev_version

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


if __name__ == "__main__":
		__snake_case			:     int										=      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.')
		__snake_case			:     Tuple										=      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'''



from argparse import ArgumentParser

from .add_new_model import AddNewModelCommand
from .add_new_model_like import AddNewModelLikeCommand
from .convert import ConvertCommand
from .download import DownloadCommand
from .env import EnvironmentCommand
from .lfs import LfsCommands
from .pt_to_tf import PTtoTFCommand
from .run import RunCommand
from .serving import ServeCommand
from .user import UserCommands
def 						__lowerCamelCase	(       )	->							List[Any]:






						"""simple docstring"""





						A__					:       List[Any]     =ArgumentParser("""Transformers CLI tool""",		usage="""transformers-cli <command> [<args>]"""	)
						A__					:       List[Any]     =parser.add_subparsers(help="""transformers-cli command helpers"""	)

						# Register commands
						ConvertCommand.register_subcommand(__snake_case	)
						DownloadCommand.register_subcommand(__snake_case	)
						EnvironmentCommand.register_subcommand(__snake_case	)
						RunCommand.register_subcommand(__snake_case	)
						ServeCommand.register_subcommand(__snake_case	)
						UserCommands.register_subcommand(__snake_case	)
						AddNewModelCommand.register_subcommand(__snake_case	)
						AddNewModelLikeCommand.register_subcommand(__snake_case	)
						LfsCommands.register_subcommand(__snake_case	)
						PTtoTFCommand.register_subcommand(__snake_case	)

						# Let's go
						A__					:       List[str]     =parser.parse_args()

						if not hasattr(__snake_case,		"""func"""	):
												parser.print_help()
												exit(1	)

						# Run
						A__					:       Optional[Any]     =args.func(__snake_case	)
						service.run()


if __name__ == "__main__":
		main()

