





'''simple docstring'''

import argparse
import os
import re

import packaging.version


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







def 				UpperCAmelCase_     (						lowerCAmelCase_		,				lowerCAmelCase_		,				lowerCAmelCase_				):

				"""simple docstring"""






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







def 				UpperCAmelCase_     (						lowerCAmelCase_				):

				"""simple docstring"""






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







def 				UpperCAmelCase_     (						lowerCAmelCase_		,				lowerCAmelCase_=False				):

				"""simple docstring"""






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







def 				UpperCAmelCase_     (						):

				"""simple docstring"""






				lowercase    =			"🤗 Transformers currently provides the following architectures"
				lowercase    =			"1. Want to contribute a new model?"
				with open(lowercase_		,				"r"		,				encoding="utf-8"		,				newline="\n"				) as f:
								lowercase    =			f.readlines()

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

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

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







def 				UpperCAmelCase_     (						):

				"""simple docstring"""






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







def 				UpperCAmelCase_     (						lowerCAmelCase_=False				):

				"""simple docstring"""






				lowercase    =			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:
								lowercase    =			default_version.base_version
				elif patch:
								lowercase    =			f'{default_version.major}.{default_version.minor}.{default_version.micro + 1}'
				else:
								lowercase    =			f'{default_version.major}.{default_version.minor + 1}.0'

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

				print(f'Updating version to {version}.'				)
				global_version_update(lowercase_		,				patch=lowercase_				)
				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"""






				lowercase    =			get_version()
				lowercase    =			f'{current_version.major}.{current_version.minor + 1}.0.dev0'
				lowercase    =			current_version.base_version

				# Check with the user we got that right.
				lowercase    =			input(f'Which version are we developing now? [{dev_version}]'				)
				if len(lowercase_				) == 0:
								lowercase    =			dev_version

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


if __name__ == "__main__":
			__lowerCamelCase			:			Any									=      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			:			Optional[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()












'''simple docstring'''







import os
import sys
import unittest


__lowerCAmelCase        =							os.path.abspath(os.path.dirname(os.path.dirname(os.path.dirname(__file__))))
sys.path.append(os.path.join(git_repo_path, "utils"))

import get_test_info  # noqa: E402
from get_test_info import (  # noqa: E402
    get_model_to_test_mapping,
    get_model_to_tester_mapping,
    get_test_to_tester_mapping,
)


__lowerCAmelCase        =							os.path.join("tests", "models", "bert", "test_modeling_bert.py")
__lowerCAmelCase        =							os.path.join("tests", "models", "blip", "test_modeling_blip.py")




class   __SCREAMING_SNAKE_CASE       (unittest.TestCase       ):


  """simple docstring"""


  def    _a       (			self	):






         """simple docstring"""


         a_						     =			get_test_to_tester_mapping(UpperCamelCase__	)
         a_						     =			get_test_to_tester_mapping(UpperCamelCase__	)

         a_						     =			{'BertModelTest': 'BertModelTester'}

         a_						     =			{
             'BlipModelTest': 'BlipModelTester',
             'BlipTextImageModelTest': 'BlipTextImageModelsModelTester',
             'BlipTextModelTest': 'BlipTextModelTester',
             'BlipTextRetrievalModelTest': 'BlipTextRetrievalModelTester',
             'BlipVQAModelTest': 'BlipVQAModelTester',
             'BlipVisionModelTest': 'BlipVisionModelTester',
         }

         self.assertEqual(get_test_info.to_json(UpperCamelCase__	)   ,	UpperCamelCase__	)
         self.assertEqual(get_test_info.to_json(UpperCamelCase__	)   ,	UpperCamelCase__	)







  def    _a       (			self	):






         """simple docstring"""


         a_						     =			get_model_to_test_mapping(UpperCamelCase__	)
         a_						     =			get_model_to_test_mapping(UpperCamelCase__	)

         a_						     =			{
             'BertForMaskedLM': ['BertModelTest'],
             'BertForMultipleChoice': ['BertModelTest'],
             'BertForNextSentencePrediction': ['BertModelTest'],
             'BertForPreTraining': ['BertModelTest'],
             'BertForQuestionAnswering': ['BertModelTest'],
             'BertForSequenceClassification': ['BertModelTest'],
             'BertForTokenClassification': ['BertModelTest'],
             'BertLMHeadModel': ['BertModelTest'],
             'BertModel': ['BertModelTest'],
         }

         a_						     =			{
             'BlipForConditionalGeneration': ['BlipTextImageModelTest'],
             'BlipForImageTextRetrieval': ['BlipTextRetrievalModelTest'],
             'BlipForQuestionAnswering': ['BlipVQAModelTest'],
             'BlipModel': ['BlipModelTest'],
             'BlipTextModel': ['BlipTextModelTest'],
             'BlipVisionModel': ['BlipVisionModelTest'],
         }

         self.assertEqual(get_test_info.to_json(UpperCamelCase__	)   ,	UpperCamelCase__	)
         self.assertEqual(get_test_info.to_json(UpperCamelCase__	)   ,	UpperCamelCase__	)







  def    _a       (			self	):






         """simple docstring"""


         a_						     =			get_model_to_tester_mapping(UpperCamelCase__	)
         a_						     =			get_model_to_tester_mapping(UpperCamelCase__	)

         a_						     =			{
             'BertForMaskedLM': ['BertModelTester'],
             'BertForMultipleChoice': ['BertModelTester'],
             'BertForNextSentencePrediction': ['BertModelTester'],
             'BertForPreTraining': ['BertModelTester'],
             'BertForQuestionAnswering': ['BertModelTester'],
             'BertForSequenceClassification': ['BertModelTester'],
             'BertForTokenClassification': ['BertModelTester'],
             'BertLMHeadModel': ['BertModelTester'],
             'BertModel': ['BertModelTester'],
         }

         a_						     =			{
             'BlipForConditionalGeneration': ['BlipTextImageModelsModelTester'],
             'BlipForImageTextRetrieval': ['BlipTextRetrievalModelTester'],
             'BlipForQuestionAnswering': ['BlipVQAModelTester'],
             'BlipModel': ['BlipModelTester'],
             'BlipTextModel': ['BlipTextModelTester'],
             'BlipVisionModel': ['BlipVisionModelTester'],
         }

         self.assertEqual(get_test_info.to_json(UpperCamelCase__	)   ,	UpperCamelCase__	)
         self.assertEqual(get_test_info.to_json(UpperCamelCase__	)   ,	UpperCamelCase__	)




