


import collections
import importlib.util
import os
import re
from pathlib import Path


__UpperCamelCase     		=							'src/transformers'


# Matches is_xxx_available()
__UpperCamelCase     		=							re.compile(R'is\_([a-z_]*)_available()')
# Catches a one-line _import_struct = {xxx}
__UpperCamelCase     		=							re.compile(R'^_import_structure\s+=\s+\{([^\}]+)\}')
# Catches a line with a key-values pattern: "bla": ["foo", "bar"]
__UpperCamelCase     		=							re.compile(R'\s+"\S*":\s+\[([^\]]*)\]')
# Catches a line if not is_foo_available
__UpperCamelCase     		=							re.compile(R'^\s*if\s+not\s+is\_[a-z_]*\_available\(\)')
# Catches a line _import_struct["bla"].append("foo")
__UpperCamelCase     		=							re.compile(R'^\s*_import_structure\["\S*"\]\.append\("(\S*)"\)')
# Catches a line _import_struct["bla"].extend(["foo", "bar"]) or _import_struct["bla"] = ["foo", "bar"]
__UpperCamelCase     		=							re.compile(R'^\s*_import_structure\[\S*\](?:\.extend\(|\s*=\s+)\[([^\]]*)\]')
# Catches a line with an object between quotes and a comma:     "MyModel",
__UpperCamelCase     		=							re.compile('^\s+"([^"]+)",')
# Catches a line with objects between brackets only:    ["foo", "bar"],
__UpperCamelCase     		=							re.compile('^\s+\[([^\]]+)\]')
# Catches a line with from foo import bar, bla, boo
__UpperCamelCase     		=							re.compile(R'\s+from\s+\S*\s+import\s+([^\(\s].*)\n')
# Catches a line with try:
__UpperCamelCase     		=							re.compile(R'^\s*try:')
# Catches a line with else:
__UpperCamelCase     		=							re.compile(R'^\s*else:')
def 							UpperCamelCase_(					_A :int	)->		List[Any]:






			if _re_test_backend.search(lowerCamelCase_	) is None:
						return None
			UpperCamelCase__       =							[b[0] for b in _re_backend.findall(lowerCamelCase_	)]
			backends.sort()
			return "_and_".join(lowerCamelCase_	)
def 							UpperCamelCase_(					_A :Any	)->		Any:






			with open(lowerCamelCase_					,  "r"					,  encoding="utf-8"					,  newline="\n"	) as f:
						UpperCamelCase__       =							f.readlines()

			UpperCamelCase__       =							0
			while line_index < len(lowerCamelCase_	) and not lines[line_index].startswith("_import_structure = {"	):
						line_index += 1

			# If this is a traditional init, just return.
			if line_index >= len(lowerCamelCase_	):
						return None

			# First grab the objects without a specific backend in _import_structure
			UpperCamelCase__       =							[]
			while not lines[line_index].startswith("if TYPE_CHECKING"	) and find_backend(lines[line_index]	) is None:
						UpperCamelCase__       =							lines[line_index]
						# If we have everything on a single line, let's deal with it.
						if _re_one_line_import_struct.search(lowerCamelCase_	):
									UpperCamelCase__       =							_re_one_line_import_struct.search(lowerCamelCase_	).groups()[0]
									UpperCamelCase__       =							re.findall("\[([^\]]+)\]"					,  lowerCamelCase_	)
									for imp in imports:
												objects.extend([obj[1:-1] for obj in imp.split(", "	)]	)
									line_index += 1
									continue
						UpperCamelCase__       =							_re_import_struct_key_value.search(lowerCamelCase_	)
						if single_line_import_search is not None:
									UpperCamelCase__       =							[obj[1:-1] for obj in single_line_import_search.groups()[0].split(", "	) if len(lowerCamelCase_	) > 0]
									objects.extend(lowerCamelCase_	)
						elif line.startswith(" " * 8 + "\""	):
									objects.append(line[9:-3]	)
						line_index += 1

			UpperCamelCase__       =							{"none": objects}
			# Let's continue with backend-specific objects in _import_structure
			while not lines[line_index].startswith("if TYPE_CHECKING"	):
						# If the line is an if not is_backend_available, we grab all objects associated.
						UpperCamelCase__       =							find_backend(lines[line_index]	)
						# Check if the backend declaration is inside a try block:
						if _re_try.search(lines[line_index - 1]	) is None:
									UpperCamelCase__       =							None

						if backend is not None:
									line_index += 1

									# Scroll until we hit the else block of try-except-else
									while _re_else.search(lines[line_index]	) is None:
												line_index += 1

									line_index += 1

									UpperCamelCase__       =							[]
									# Until we unindent, add backend objects to the list
									while len(lines[line_index]	) <= 1 or lines[line_index].startswith(" " * 4	):
												UpperCamelCase__       =							lines[line_index]
												if _re_import_struct_add_one.search(lowerCamelCase_	) is not None:
															objects.append(_re_import_struct_add_one.search(lowerCamelCase_	).groups()[0]	)
												elif _re_import_struct_add_many.search(lowerCamelCase_	) is not None:
															UpperCamelCase__       =							_re_import_struct_add_many.search(lowerCamelCase_	).groups()[0].split(", "	)
															UpperCamelCase__       =							[obj[1:-1] for obj in imports if len(lowerCamelCase_	) > 0]
															objects.extend(lowerCamelCase_	)
												elif _re_between_brackets.search(lowerCamelCase_	) is not None:
															UpperCamelCase__       =							_re_between_brackets.search(lowerCamelCase_	).groups()[0].split(", "	)
															UpperCamelCase__       =							[obj[1:-1] for obj in imports if len(lowerCamelCase_	) > 0]
															objects.extend(lowerCamelCase_	)
												elif _re_quote_object.search(lowerCamelCase_	) is not None:
															objects.append(_re_quote_object.search(lowerCamelCase_	).groups()[0]	)
												elif line.startswith(" " * 8 + "\""	):
															objects.append(line[9:-3]	)
												elif line.startswith(" " * 12 + "\""	):
															objects.append(line[13:-3]	)
												line_index += 1

									UpperCamelCase__       =							objects
						else:
									line_index += 1

    # At this stage we are in the TYPE_CHECKING part, first grab the objects without a specific backend
			UpperCamelCase__       =							[]
			while (
			    line_index < len(lowerCamelCase_	)
			    and find_backend(lines[line_index]	) is None
			    and not lines[line_index].startswith("else"	)
			):
						UpperCamelCase__       =							lines[line_index]
						UpperCamelCase__       =							_re_import.search(lowerCamelCase_	)
						if single_line_import_search is not None:
									objects.extend(single_line_import_search.groups()[0].split(", "	)	)
						elif line.startswith(" " * 8	):
									objects.append(line[8:-2]	)
						line_index += 1

			UpperCamelCase__       =							{"none": objects}
			# Let's continue with backend-specific objects
			while line_index < len(lowerCamelCase_	):
						# If the line is an if is_backend_available, we grab all objects associated.
						UpperCamelCase__       =							find_backend(lines[line_index]	)
						# Check if the backend declaration is inside a try block:
						if _re_try.search(lines[line_index - 1]	) is None:
									UpperCamelCase__       =							None

						if backend is not None:
									line_index += 1

									# Scroll until we hit the else block of try-except-else
									while _re_else.search(lines[line_index]	) is None:
												line_index += 1

									line_index += 1

									UpperCamelCase__       =							[]
									# Until we unindent, add backend objects to the list
									while len(lines[line_index]	) <= 1 or lines[line_index].startswith(" " * 8	):
												UpperCamelCase__       =							lines[line_index]
												UpperCamelCase__       =							_re_import.search(lowerCamelCase_	)
												if single_line_import_search is not None:
															objects.extend(single_line_import_search.groups()[0].split(", "	)	)
												elif line.startswith(" " * 12	):
															objects.append(line[12:-2]	)
												line_index += 1

									UpperCamelCase__       =							objects
						else:
									line_index += 1

			return import_dict_objects, type_hint_objects
def 							UpperCamelCase_(					_A :Tuple					,  _A :int	)->		Dict:






			def find_duplicates(_A :Optional[Any]	):
						return [k for k, v in collections.Counter(lowerCamelCase_	).items() if v > 1]

			if list(import_dict_objects.keys()	) != list(type_hint_objects.keys()	):
						return ["Both sides of the init do not have the same backends!"]

			UpperCamelCase__       =							[]
			for key in import_dict_objects.keys():
						UpperCamelCase__       =							find_duplicates(import_dict_objects[key]	)
						if duplicate_imports:
									errors.append(F'''Duplicate _import_structure definitions for: {duplicate_imports}'''	)
						UpperCamelCase__       =							find_duplicates(type_hint_objects[key]	)
						if duplicate_type_hints:
									errors.append(F'''Duplicate TYPE_CHECKING objects for: {duplicate_type_hints}'''	)

						if sorted(set(import_dict_objects[key]	)	) != sorted(set(type_hint_objects[key]	)	):
									UpperCamelCase__       =							"base imports" if key == "none" else F'''{key} backend'''
									errors.append(F'''Differences for {name}:'''	)
									for a in type_hint_objects[key]:
												if a not in import_dict_objects[key]:
															errors.append(F'''  {a} in TYPE_HINT but not in _import_structure.'''	)
									for a in import_dict_objects[key]:
												if a not in type_hint_objects[key]:
															errors.append(F'''  {a} in _import_structure but not in TYPE_HINT.'''	)
			return errors
def 							UpperCamelCase_(					)->		Optional[int]:
			UpperCamelCase__       =							[]
			for root, _, files in os.walk(lowerCamelCase_	):
						if "__init__.py" in files:
									UpperCamelCase__       =							os.path.join(lowerCamelCase_					,  "__init__.py"	)
									UpperCamelCase__       =							parse_init(lowerCamelCase_	)
									if objects is not None:
												UpperCamelCase__       =							analyze_results(*lowerCamelCase_	)
												if len(lowerCamelCase_	) > 0:
															UpperCamelCase__       =							F'''Problem in {fname}, both halves do not define the same objects.\n{errors[0]}'''
															failures.append("\n".join(lowerCamelCase_	)	)
			if len(lowerCamelCase_	) > 0:
						raise ValueError("\n\n".join(lowerCamelCase_	)	)
def 							UpperCamelCase_(					)->		List[str]:
			UpperCamelCase__       =							[]
			for path, directories, files in os.walk(lowerCamelCase_	):
						for folder in directories:
									# Ignore private modules
									if folder.startswith("_"	):
												directories.remove(lowerCamelCase_	)
												continue
									# Ignore leftovers from branches (empty folders apart from pycache)
									if len(list((Path(lowerCamelCase_	) / folder).glob("*.py"	)	)	) == 0:
												continue
									UpperCamelCase__       =							str((Path(lowerCamelCase_	) / folder).relative_to(lowerCamelCase_	)	)
									UpperCamelCase__       =							short_path.replace(os.path.sep					,  "."	)
									submodules.append(lowerCamelCase_	)
						for fname in files:
									if fname == "__init__.py":
												continue
									UpperCamelCase__       =							str((Path(lowerCamelCase_	) / fname).relative_to(lowerCamelCase_	)	)
									UpperCamelCase__       =							short_path.replace(".py"					,  ""	).replace(os.path.sep					,  "."	)
									if len(submodule.split("."	)	) == 1:
												submodules.append(lowerCamelCase_	)
			return submodules


__UpperCamelCase     		=							[
    'convert_pytorch_checkpoint_to_tf2',
    'modeling_flax_pytorch_utils',
]
def 							UpperCamelCase_(					)->		Optional[int]:
			UpperCamelCase__       =							importlib.util.spec_from_file_location(
			    "transformers"					,  os.path.join(lowerCamelCase_					,  "__init__.py"	)					,  submodule_search_locations=[PATH_TO_TRANSFORMERS]					,  )
			UpperCamelCase__       =							spec.loader.load_module()

			UpperCamelCase__       =							[
			    module
			    for module in get_transformers_submodules()
			    if module not in IGNORE_SUBMODULES and module not in transformers._import_structure.keys()
			]
			if len(lowerCamelCase_	) > 0:
						UpperCamelCase__       =							"\n".join(F'''- {module}''' for module in module_not_registered	)
						raise ValueError(
						    "The following submodules are not properly registered in the main init of Transformers:\n"
						    F'''{list_of_modules}\n'''
						    "Make sure they appear somewhere in the keys of `_import_structure` with an empty list as value."	)


if __name__ == "__main__":
						check_all_inits()
						check_submodules()







"""simple docstring"""







import contextlib
import importlib
import io
import unittest

import transformers

# Try to import everything from transformers to ensure every object can be loaded.
from transformers import *  # noqa F406
from transformers.testing_utils import DUMMY_UNKNOWN_IDENTIFIER, require_flax, require_tf, require_torch
from transformers.utils import ContextManagers, find_labels, is_flax_available, is_tf_available, is_torch_available


if is_torch_available():
			from transformers import BertForPreTraining, BertForQuestionAnswering, BertForSequenceClassification

if is_tf_available():
			from transformers import TFBertForPreTraining, TFBertForQuestionAnswering, TFBertForSequenceClassification

if is_flax_available():
			from transformers import FlaxBertForPreTraining, FlaxBertForQuestionAnswering, FlaxBertForSequenceClassification


A		=						DUMMY_UNKNOWN_IDENTIFIER
# An actual model hosted on huggingface.co

A		=						'main'
# Default branch name
A		=						'f2c752cfc5c0ab6f4bdec59acea69eefbee381c2'
# One particular commit (not the top of `main`)
A		=						'aaaaaaa'
# This commit does not exist, so we should 404.

A		=						'd9e9f15bc825e4b2c9249e9578f884bbcb5e3684'
# Sha-1 of config.json on the top of `main`, for checking purposes
A		=						'4b243c475af8d0a7754e87d7d096c92e5199ec2fe168a2ee7998e3b8e9bcb1d3'

@contextlib.contextmanager
def  __SCREAMING_SNAKE_CASE		(			):
						"""simple docstring"""






						print("Welcome!" )
						yield
						print("Bye!" )

@contextlib.contextmanager
def  __SCREAMING_SNAKE_CASE		(			):
						"""simple docstring"""






						print("Bonjour!" )
						yield
						print("Au revoir!" )

class       _a  ( unittest.TestCase):



			def 				__lowercase					(			self							:				Dict		)							->					Optional[int]:
									# If the spec is missing, importlib would not be able to import the module dynamically.
									assert transformers.__spec__ is not None
									assert importlib.util.find_spec("transformers"		) is not None



class       _a  ( unittest.TestCase):



			@unittest.mock.patch("sys.stdout"   ,	new_callable=io.StringIO		)
			def 				__lowercase					(			self							:				Union[str, Any]   ,	_lowercase							:				Optional[int]		)							->					Optional[Any]:
									with ContextManagers([]		):
															print("Transformers are awesome!"		)
									# The print statement adds a new line at the end of the output
									self.assertEqual(mock_stdout.getvalue()   ,	"Transformers are awesome!\n"		)



			@unittest.mock.patch("sys.stdout"   ,	new_callable=io.StringIO		)
			def 				__lowercase					(			self							:				Any   ,	_lowercase							:				Any		)							->					Dict:
									with ContextManagers([context_en()]		):
															print("Transformers are awesome!"		)
									# The output should be wrapped with an English welcome and goodbye
									self.assertEqual(mock_stdout.getvalue()   ,	"Welcome!\nTransformers are awesome!\nBye!\n"		)



			@unittest.mock.patch("sys.stdout"   ,	new_callable=io.StringIO		)
			def 				__lowercase					(			self							:				str   ,	_lowercase							:				List[Any]		)							->					Optional[int]:
									with ContextManagers([context_fr(), context_en()]		):
															print("Transformers are awesome!"		)
									# The output should be wrapped with an English and French welcome and goodbye
									self.assertEqual(mock_stdout.getvalue()   ,	"Bonjour!\nWelcome!\nTransformers are awesome!\nBye!\nAu revoir!\n"		)



			@require_torch
			def 				__lowercase					(			self							:				Any		)							->					Union[str, Any]:
									self.assertEqual(find_labels(_lowercase		)   ,	["labels"]		)
									self.assertEqual(find_labels(_lowercase		)   ,	["labels", "next_sentence_label"]		)
									self.assertEqual(find_labels(_lowercase		)   ,	["start_positions", "end_positions"]		)

									class       _a  ( SCREAMING_SNAKE_CASE__):
												pass



									self.assertEqual(find_labels(_lowercase		)   ,	["labels"]		)



			@require_tf
			def 				__lowercase					(			self							:				Optional[Any]		)							->					int:
									self.assertEqual(find_labels(_lowercase		)   ,	["labels"]		)
									self.assertEqual(find_labels(_lowercase		)   ,	["labels", "next_sentence_label"]		)
									self.assertEqual(find_labels(_lowercase		)   ,	["start_positions", "end_positions"]		)

									class       _a  ( SCREAMING_SNAKE_CASE__):
												pass



									self.assertEqual(find_labels(_lowercase		)   ,	["labels"]		)



			@require_flax
			def 				__lowercase					(			self							:				Tuple		)							->					List[Any]:
									# Flax models don't have labels
									self.assertEqual(find_labels(_lowercase		)   ,	[]		)
									self.assertEqual(find_labels(_lowercase		)   ,	[]		)
									self.assertEqual(find_labels(_lowercase		)   ,	[]		)

									class       _a  ( SCREAMING_SNAKE_CASE__):
												pass



									self.assertEqual(find_labels(_lowercase		)   ,	[]		)



