import collections
import os
import re
from pathlib import Path


__SCREAMING_SNAKE_CASE						:   Dict         =			"src/transformers"


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

						'''simple docstring'''



						if _re_test_backend.search(__lowerCAmelCase						) is None:
												return None
						_snake_case						:					Any    =   [b[0] for b in _re_backend.findall(__lowerCAmelCase						)]
						backends.sort()
						return "_and_".join(__lowerCAmelCase						)
def  snake_case						(__lowercase						)	->	List[str]:

						'''simple docstring'''



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

						_snake_case						:					Dict    =   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
						_snake_case						:					int    =   []
						while not lines[line_index].startswith("if TYPE_CHECKING"						) and find_backend(lines[line_index]						) is None:
												_snake_case						:					Optional[Any]    =   lines[line_index]
												# If we have everything on a single line, let's deal with it.
												if _re_one_line_import_struct.search(__lowerCAmelCase						):
																		_snake_case						:					Union[str, Any]    =   _re_one_line_import_struct.search(__lowerCAmelCase						).groups()[0]
																		_snake_case						:					Union[str, Any]    =   re.findall(r"\[([^\]]+)\]" ,      __lowerCAmelCase						)
																		for imp in imports:
																								objects.extend([obj[1:-1] for obj in imp.split(", "						)]						)
																		line_index += 1
																		continue
												_snake_case						:					Optional[int]    =   _re_import_struct_key_value.search(__lowerCAmelCase						)
												if single_line_import_search is not None:
																		_snake_case						:					Dict    =   [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

						_snake_case						:					Optional[int]    =   {"""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.
												_snake_case						:					int    =   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:
																		_snake_case						:					int    =   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

																		_snake_case						:					Any    =   []
																		# Until we unindent, add backend objects to the list
																		while len(lines[line_index]						) <= 1 or lines[line_index].startswith(" " * 4						):
																								_snake_case						:					Union[str, Any]    =   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:
																														_snake_case						:					Optional[int]    =   _re_import_struct_add_many.search(__lowerCAmelCase						).groups()[0].split(", "						)
																														_snake_case						:					Optional[Any]    =   [obj[1:-1] for obj in imports if len(__lowerCAmelCase						) > 0]
																														objects.extend(__lowerCAmelCase						)
																								elif _re_between_brackets.search(__lowerCAmelCase						) is not None:
																														_snake_case						:					Tuple    =   _re_between_brackets.search(__lowerCAmelCase						).groups()[0].split(", "						)
																														_snake_case						:					Any    =   [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

																		_snake_case						:					Union[str, Any]    =   objects
												else:
																		line_index += 1

    # At this stage we are in the TYPE_CHECKING part, first grab the objects without a specific backend
						_snake_case						:					Optional[int]    =   []
						while (
						    line_index < len(__lowerCAmelCase						)
						    and find_backend(lines[line_index]						) is None
						    and not lines[line_index].startswith("else"						)
						):
												_snake_case						:					Optional[int]    =   lines[line_index]
												_snake_case						:					int    =   _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

						_snake_case						:					Optional[Any]    =   {"""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.
												_snake_case						:					List[str]    =   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:
																		_snake_case						:					List[Any]    =   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

																		_snake_case						:					Any    =   []
																		# Until we unindent, add backend objects to the list
																		while len(lines[line_index]						) <= 1 or lines[line_index].startswith(" " * 8						):
																								_snake_case						:					List[str]    =   lines[line_index]
																								_snake_case						:					str    =   _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

																		_snake_case						:					Dict    =   objects
												else:
																		line_index += 1

						return import_dict_objects, type_hint_objects
def  snake_case						(__lowercase ,      __lowercase						)	->	Optional[int]:

						'''simple docstring'''



						def find_duplicates(__lowercase						):
												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!"]

						_snake_case						:					List[Any]    =   []
						for key in import_dict_objects.keys():
												_snake_case						:					Any    =   find_duplicates(import_dict_objects[key]						)
												if duplicate_imports:
																		errors.append(F"""Duplicate _import_structure definitions for: {duplicate_imports}"""						)
												_snake_case						:					Tuple    =   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]						)						):
																		_snake_case						:					Any    =   """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  snake_case						()	->	str:

						'''simple docstring'''



						_snake_case						:					Optional[int]    =   []
						for root, _, files in os.walk(__lowerCAmelCase						):
												if "__init__.py" in files:
																		_snake_case						:					Optional[Any]    =   os.path.join(__lowerCAmelCase ,      "__init__.py"						)
																		_snake_case						:					Dict    =   parse_init(__lowerCAmelCase						)
																		if objects is not None:
																								_snake_case						:					List[str]    =   analyze_results(*__lowerCAmelCase						)
																								if len(__lowerCAmelCase						) > 0:
																														_snake_case						:					List[Any]    =   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  snake_case						()	->	Dict:

						'''simple docstring'''



						_snake_case						:					Dict    =   []
						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
																		_snake_case						:					Union[str, Any]    =   str((Path(__lowerCAmelCase						) / folder).relative_to(__lowerCAmelCase						)						)
																		_snake_case						:					List[str]    =   short_path.replace(os.path.sep ,      "."						)
																		submodules.append(__lowerCAmelCase						)
												for fname in files:
																		if fname == "__init__.py":
																								continue
																		_snake_case						:					Tuple    =   str((Path(__lowerCAmelCase						) / fname).relative_to(__lowerCAmelCase						)						)
																		_snake_case						:					Optional[int]    =   short_path.replace(".py" ,      ""						).replace(os.path.sep ,      "."						)
																		if len(submodule.split("."						)						) == 1:
																								submodules.append(__lowerCAmelCase						)
						return submodules


__SCREAMING_SNAKE_CASE						:   Optional[Any]         =			[
    "convert_pytorch_checkpoint_to_tf2",
    "modeling_flax_pytorch_utils",
    "models.esm.openfold_utils",
]
def  snake_case						()	->	int:

						'''simple docstring'''



						from transformers.utils import direct_transformers_import

						_snake_case						:					int    =   direct_transformers_import(__lowerCAmelCase						)

						_snake_case						:					Optional[int]    =   set(transformers._import_structure.keys()						)
						# This contains all the base keys of the _import_structure object defined in the init, but if the user is missing
						# some optional dependencies, they may not have all of them. Thus we read the init to read all additions and
						# (potentiall re-) add them.
						with open(os.path.join(__lowerCAmelCase ,      "__init__.py"						) ,      "r"						) as f:
												_snake_case						:					str    =   f.read()
						import_structure_keys.update(set(re.findall(r"import_structure\[\"([^\"]*)\"\]" ,      __lowerCAmelCase						)						)						)

						_snake_case						:					Optional[int]    =   [
						    module
						    for module in get_transformers_submodules()
						    if module not in IGNORE_SUBMODULES and module not in import_structure_keys
						]

						if len(__lowerCAmelCase						) > 0:
												_snake_case						:					Dict    =   """\n""".join(F"""- {module}""" for module in module_not_registered						)
												raise ValueError(
												    "The following submodules are not properly registed 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()
def  snake_case						()	->	Dict:

						'''simple docstring'''



						_snake_case						:					List[str]    =   0
						for i in range(1 ,      1_001						):
												total += i**i
						return str(__lowercase						)[-10:]


if __name__ == "__main__":
				print(solution())