






import argparse
import os
import re

import packaging.version


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




def 					lowercase__				(					__snake_case   :							Any					,	__snake_case   :							str					,	__snake_case   :							Optional[int]  ):


					'''simple docstring'''


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




def 					lowercase__				(					__snake_case   :							List[str]  ):


					'''simple docstring'''


					for folder, directories, fnames in os.walk(SCREAMING_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(SCREAMING_SNAKE_CASE_					,	SCREAMING_SNAKE_CASE_  )					,	SCREAMING_SNAKE_CASE_					,	pattern='examples'  )




def 					lowercase__				(					__snake_case   :							Tuple					,	__snake_case   :							Union[str, Any]=False  ):


					'''simple docstring'''


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




def 					lowercase__				(					):


					'''simple docstring'''


					UpperCAmelCase_   :				Dict						=						'🤗 Transformers currently provides the following architectures'
					UpperCAmelCase_   :				Optional[Any]						=						'1. Want to contribute a new model?'
					with open(SCREAMING_SNAKE_CASE_					,	'r'					,	encoding='utf-8'					,	newline='\n'  ) as f:
										UpperCAmelCase_   :				Dict						=						f.readlines()

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

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

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




def 					lowercase__				(					):


					'''simple docstring'''


					with open(REPLACE_FILES['init']					,	'r'  ) as f:
										UpperCAmelCase_   :				Any						=						f.read()
					UpperCAmelCase_   :				Tuple						=						REPLACE_PATTERNS['init'][0].search(SCREAMING_SNAKE_CASE_  ).groups()[0]
					return packaging.version.parse(SCREAMING_SNAKE_CASE_  )




def 					lowercase__				(					__snake_case   :							Optional[Any]=False  ):


					'''simple docstring'''


					UpperCAmelCase_   :				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:
										UpperCAmelCase_   :				int						=						default_version.base_version
					elif patch:
										UpperCAmelCase_   :				List[str]						=						F"{default_version.major}.{default_version.minor}.{default_version.micro + 1}"
					else:
										UpperCAmelCase_   :				Optional[Any]						=						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(SCREAMING_SNAKE_CASE_  ) == 0:
										UpperCAmelCase_   :				Union[str, Any]						=						default_version

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




def 					lowercase__				(					):


					'''simple docstring'''


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

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

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


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














def 					lowercase__				(					__snake_case   :							str					,	__snake_case   :							int					,	__snake_case   :							List[str]  ):


					'''simple docstring'''


					if n == 0:
										return 1

					elif n % 2 == 1:
										return (binary_exponentiation(__snake_case					,	n - 1					,	__snake_case  ) * a) % mod

					else:
										UpperCAmelCase_   :				Optional[int]						=						binary_exponentiation(__snake_case					,	n / 2					,	__snake_case  )
										return (b * b) % mod


# a prime number
__UpperCAmelCase     							=						701

__UpperCAmelCase     							=						1000000000
__UpperCAmelCase     							=						10

# using binary exponentiation function, O(log(p)):
print((a / b) % p == (a * binary_exponentiation(b, p - 2, p)) % p)






print((a / b) % p == (a * b ** (p - 2)) % p)






