



import argparse
import os
import re

import packaging.version


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






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






def        __lowerCAmelCase		(	__lowerCamelCase						:     Union[str, Any]						)	->    str:
					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						:     Tuple					, __lowerCamelCase						:     Optional[Any]=False						)	->    int:
					for pattern, fname in REPLACE_FILES.items():
										update_version_in_file(__lowerCamelCase					, __lowerCamelCase					, __lowerCamelCase						)
					if not patch:
										update_version_in_examples(__lowerCamelCase						)






def        __lowerCAmelCase		(	)	->    Dict:
					__lowerCAmelCase						 ="""🤗 Transformers currently provides the following architectures"""
					__lowerCAmelCase						 ="""1. Want to contribute a new model?"""
					with open(__lowerCamelCase					, """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(__lowerCamelCase					, """w"""					, encoding="""utf-8"""					, newline="""\n"""						) as f:
										f.writelines(__lowerCamelCase						)






def        __lowerCAmelCase		(	)	->    Union[str, Any]:
					with open(REPLACE_FILES["""init"""]					, """r"""						) as f:
										__lowerCAmelCase						 =f.read()
					__lowerCAmelCase						 =REPLACE_PATTERNS["""init"""][0].search(__lowerCamelCase						).groups()[0]
					return packaging.version.parse(__lowerCamelCase						)






def        __lowerCAmelCase		(	__lowerCamelCase						:     Any=False						)	->    Any:
					__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(__lowerCamelCase						) == 0:
										__lowerCAmelCase						 =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		(	)	->    Dict:
					__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(__lowerCamelCase						) == 0:
										__lowerCAmelCase						 =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__":
				lowercase_													=      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.''')
				lowercase_													=      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()









from __future__ import annotations






class     __a			:



	def __init__(    self				:     Optional[int]					,						snake_case_				:     int = 0)->				List[str]:
						__lowerCAmelCase						 =key



	def 		UpperCamelCase				(    self				:     Any					,						snake_case_				:     str					,						snake_case_				:     int)->				list[str]:
						assert isinstance(snake_case_					,						snake_case_) and isinstance(snake_case_					,						snake_case_)

						__lowerCAmelCase						 =key or self.__key or 1

						# make sure key is an appropriate size
						key %= 2_55

						return [chr(ord(snake_case_) ^ key) for ch in content]



	def 		UpperCamelCase				(    self				:     Tuple					,						snake_case_				:     str					,						snake_case_				:     int)->				list[str]:
						assert isinstance(snake_case_					,						snake_case_) and isinstance(snake_case_					,						snake_case_)

						__lowerCAmelCase						 =key or self.__key or 1

						# make sure key is an appropriate size
						key %= 2_55

						return [chr(ord(snake_case_) ^ key) for ch in content]



	def 		UpperCamelCase				(    self				:     str					,						snake_case_				:     str					,						snake_case_				:     int = 0)->				str:
						assert isinstance(snake_case_					,						snake_case_) and isinstance(snake_case_					,						snake_case_)

						__lowerCAmelCase						 =key or self.__key or 1

						# make sure key can be any size
						while key > 2_55:
											key -= 2_55

						# This will be returned
						__lowerCAmelCase						 =""""""

						for ch in content:
											ans += chr(ord(snake_case_) ^ key)

						return ans



	def 		UpperCamelCase				(    self				:     Tuple					,						snake_case_				:     str					,						snake_case_				:     int = 0)->				str:
						assert isinstance(snake_case_					,						snake_case_) and isinstance(snake_case_					,						snake_case_)

						__lowerCAmelCase						 =key or self.__key or 1

						# make sure key can be any size
						while key > 2_55:
											key -= 2_55

						# This will be returned
						__lowerCAmelCase						 =""""""

						for ch in content:
											ans += chr(ord(snake_case_) ^ key)

						return ans



	def 		UpperCamelCase				(    self				:     int					,						snake_case_				:     str					,						snake_case_				:     int = 0)->				bool:
						assert isinstance(snake_case_					,						snake_case_) and isinstance(snake_case_					,						snake_case_)

						try:
											with open(snake_case_) as fin, open("""encrypt.out"""					,						"""w+""") as fout:
																# actual encrypt-process
																for line in fin:
																					fout.write(self.encrypt_string(snake_case_					,						snake_case_))

						except OSError:
											return False

						return True



	def 		UpperCamelCase				(    self				:     Tuple					,						snake_case_				:     str					,						snake_case_				:     int)->				bool:
						assert isinstance(snake_case_					,						snake_case_) and isinstance(snake_case_					,						snake_case_)

						try:
											with open(snake_case_) as fin, open("""decrypt.out"""					,						"""w+""") as fout:
																# actual encrypt-process
																for line in fin:
																					fout.write(self.decrypt_string(snake_case_					,						snake_case_))

						except OSError:
											return False

						return True


# Tests
# crypt = XORCipher()
# key = 67

# # test encrypt
# print(crypt.encrypt("hallo welt",key))
# # test decrypt
# print(crypt.decrypt(crypt.encrypt("hallo welt",key), key))

# # test encrypt_string
# print(crypt.encrypt_string("hallo welt",key))

# # test decrypt_string
# print(crypt.decrypt_string(crypt.encrypt_string("hallo welt",key),key))

# if (crypt.encrypt_file("test.txt",key)):
#       print("encrypt successful")
# else:
#       print("encrypt unsuccessful")

# if (crypt.decrypt_file("encrypt.out",key)):
#       print("decrypt successful")
# else:
#       print("decrypt unsuccessful")




