


'''simple docstring'''






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    _snake_case  (	A			)		->       List[str]:
							if _re_test_backend.search(A			) is None:
														return None
							lowerCAmelCase__			  =      [b[0] for b in _re_backend.findall(A			)]
							backends.sort()
							return "_and_".join(A			)


def    _snake_case  (	A			)		->       Optional[int]:
							with open(A					,       '''r'''					,       encoding='''utf-8'''					,       newline='''\n'''			) as f:
														lowerCAmelCase__			  =      f.readlines()

							lowerCAmelCase__			  =      0
							while line_index < len(A			) and not lines[line_index].startswith('''_import_structure = {'''			):
														line_index += 1

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

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

							lowerCAmelCase__			  =      {'''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.
														lowerCAmelCase__			  =      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:
																					lowerCAmelCase__			  =      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

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

																					lowerCAmelCase__			  =      objects
														else:
																					line_index += 1

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

							lowerCAmelCase__			  =      {'''none''': objects}
							# Let's continue with backend-specific objects
							while line_index < len(A			):
														# If the line is an if is_backend_available, we grab all objects associated.
														lowerCAmelCase__			  =      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:
																					lowerCAmelCase__			  =      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

																					lowerCAmelCase__			  =      []
																					# Until we unindent, add backend objects to the list
																					while len(lines[line_index]			) <= 1 or lines[line_index].startswith(''' ''' * 8			):
																												lowerCAmelCase__			  =      lines[line_index]
																												lowerCAmelCase__			  =      _re_import.search(A			)
																												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

																					lowerCAmelCase__			  =      objects
														else:
																					line_index += 1

							return import_dict_objects, type_hint_objects


def    _snake_case  (	A					,       A			)		->       str:

							def find_duplicates(A			):
														return [k for k, v in collections.Counter(A			).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!"]

							lowerCAmelCase__			  =      []
							for key in import_dict_objects.keys():
														lowerCAmelCase__			  =      find_duplicates(import_dict_objects[key]			)
														if duplicate_imports:
																					errors.append(F"""Duplicate _import_structure definitions for: {duplicate_imports}"""			)
														lowerCAmelCase__			  =      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]			)			):
																					lowerCAmelCase__			  =      '''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  (	)		->       int:
							lowerCAmelCase__			  =      []
							for root, _, files in os.walk(A			):
														if "__init__.py" in files:
																					lowerCAmelCase__			  =      os.path.join(A					,       '''__init__.py'''			)
																					lowerCAmelCase__			  =      parse_init(A			)
																					if objects is not None:
																												lowerCAmelCase__			  =      analyze_results(*A			)
																												if len(A			) > 0:
																																			lowerCAmelCase__			  =      F"""Problem in {fname}, both halves do not define the same objects.\n{errors[0]}"""
																																			failures.append('''\n'''.join(A			)			)
							if len(A			) > 0:
														raise ValueError('''\n\n'''.join(A			)			)


def    _snake_case  (	)		->       str:
							lowerCAmelCase__			  =      []
							for path, directories, files in os.walk(A			):
														for folder in directories:
																					# Ignore private modules
																					if folder.startswith('''_'''			):
																												directories.remove(A			)
																												continue
																					# Ignore leftovers from branches (empty folders apart from pycache)
																					if len(list((Path(A			) / folder).glob('''*.py'''			)			)			) == 0:
																												continue
																					lowerCAmelCase__			  =      str((Path(A			) / folder).relative_to(A			)			)
																					lowerCAmelCase__			  =      short_path.replace(os.path.sep					,       '''.'''			)
																					submodules.append(A			)
														for fname in files:
																					if fname == "__init__.py":
																												continue
																					lowerCAmelCase__			  =      str((Path(A			) / fname).relative_to(A			)			)
																					lowerCAmelCase__			  =      short_path.replace('''.py'''					,       ''''''			).replace(os.path.sep					,       '''.'''			)
																					if len(submodule.split('''.'''			)			) == 1:
																												submodules.append(A			)
							return submodules


__UpperCAmelCase       							=				[
    '''convert_pytorch_checkpoint_to_tf2''',
    '''modeling_flax_pytorch_utils''',
]


def    _snake_case  (	)		->       str:
							# This is to make sure the transformers module imported is the one in the repo.
							lowerCAmelCase__			  =      importlib.util.spec_from_file_location(
							    '''transformers'''					,       os.path.join(A					,       '''__init__.py'''			)					,       submodule_search_locations=[PATH_TO_TRANSFORMERS]					,       )
							lowerCAmelCase__			  =      spec.loader.load_module()

							lowerCAmelCase__			  =      [
							    module
							    for module in get_transformers_submodules()
							    if module not in IGNORE_SUBMODULES and module not in transformers._import_structure.keys()
							]
							if len(A			) > 0:
														lowerCAmelCase__			  =      '''\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'''






from collections.abc import Iterator, MutableMapping
from dataclasses import dataclass
from typing import Generic, TypeVar

__UpperCAmelCase       							=				TypeVar('''KEY''')
__UpperCAmelCase       							=				TypeVar('''VAL''')




@dataclass(frozen=a__							,							slots=a__    )
class 						a__							(				Generic[KEY, VAL]    ):





							'''simple docstring'''






							lowercase__     :  KEY
							lowercase__     :  VAL




class 						a__							(				_Item    ):





							'''simple docstring'''






							def __init__(						self  )			->				None:
														super().__init__(lowerCamelCase_   ,       lowerCamelCase_  )







							def __bool__(						self  )			->				bool:
														return False

__UpperCAmelCase       							=				_DeletedItem()




class 						a__							(				MutableMapping[KEY, VAL]    ):





							'''simple docstring'''






							def __init__(						self   ,       lowerCamelCase_ = 8   ,       lowerCamelCase_ = 0.75  )			->				None:
														lowerCAmelCase__			  =      initial_block_size
														lowerCAmelCase__			  =      [None] * initial_block_size
														assert 0.0 < capacity_factor < 1.0
														lowerCAmelCase__			  =      capacity_factor
														lowerCAmelCase__			  =      0







							def     __SCREAMING_SNAKE_CASE				(						self   ,       lowerCamelCase_  )			->				int:
														return hash(lowerCamelCase_  ) % len(self._buckets  )







							def     __SCREAMING_SNAKE_CASE				(						self   ,       lowerCamelCase_  )			->				int:
														return (ind + 1) % len(self._buckets  )







							def     __SCREAMING_SNAKE_CASE				(						self   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_  )			->				bool:
														lowerCAmelCase__			  =      self._buckets[ind]
														if not stored:
																					lowerCAmelCase__			  =      _Item(lowerCamelCase_   ,       lowerCamelCase_  )
																					self._len += 1
																					return True
														elif stored.key == key:
																					lowerCAmelCase__			  =      _Item(lowerCamelCase_   ,       lowerCamelCase_  )
																					return True
														else:
																					return False







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				bool:
														lowerCAmelCase__			  =      len(self._buckets  ) * self._capacity_factor
														return len(self  ) >= int(lowerCamelCase_  )







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				bool:
														if len(self._buckets  ) <= self._initial_block_size:
																					return False
														lowerCAmelCase__			  =      len(self._buckets  ) * self._capacity_factor / 2
														return len(self  ) < limit







							def     __SCREAMING_SNAKE_CASE				(						self   ,       lowerCamelCase_  )			->				None:
														lowerCAmelCase__			  =      self._buckets
														lowerCAmelCase__			  =      [None] * new_size
														lowerCAmelCase__			  =      0
														for item in old_buckets:
																					if item:
																												self._add_item(item.key   ,       item.val  )







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				None:
														self._resize(len(self._buckets  ) * 2  )







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				None:
														self._resize(len(self._buckets  ) // 2  )







							def     __SCREAMING_SNAKE_CASE				(						self   ,       lowerCamelCase_  )			->				Iterator[int]:
														lowerCAmelCase__			  =      self._get_bucket_index(lowerCamelCase_  )
														for _ in range(len(self._buckets  )  ):
																					yield ind
																					lowerCAmelCase__			  =      self._get_next_ind(lowerCamelCase_  )







							def     __SCREAMING_SNAKE_CASE				(						self   ,       lowerCamelCase_   ,       lowerCamelCase_  )			->				None:
														for ind in self._iterate_buckets(lowerCamelCase_  ):
																					if self._try_set(lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_  ):
																												break







							def __setitem__(						self   ,       lowerCamelCase_   ,       lowerCamelCase_  )			->				None:
														if self._is_full():
																					self._size_up()

														self._add_item(lowerCamelCase_   ,       lowerCamelCase_  )







							def __delitem__(						self   ,       lowerCamelCase_  )			->				None:
														for ind in self._iterate_buckets(lowerCamelCase_  ):
																					lowerCAmelCase__			  =      self._buckets[ind]
																					if item is None:
																												raise KeyError(lowerCamelCase_  )
																					if item is _deleted:
																												continue
																					if item.key == key:
																												lowerCAmelCase__			  =      _deleted
																												self._len -= 1
																												break
														if self._is_sparse():
																					self._size_down()







							def __getitem__(						self   ,       lowerCamelCase_  )			->				VAL:
														for ind in self._iterate_buckets(lowerCamelCase_  ):
																					lowerCAmelCase__			  =      self._buckets[ind]
																					if item is None:
																												break
																					if item is _deleted:
																												continue
																					if item.key == key:
																												return item.val
														raise KeyError(lowerCamelCase_  )







							def __len__(						self  )			->				int:
														return self._len







							def __iter__(						self  )			->				Iterator[KEY]:
														yield from (item.key for item in self._buckets if item)







							def __repr__(						self  )			->				str:
														lowerCAmelCase__			  =      ''' ,'''.join(
														    F"""{item.key}: {item.val}""" for item in self._buckets if item  )
														return F"""HashMap({val_string})"""