

'''simple docstring'''






import collections
import os
import re
from pathlib import Path


lowerCAmelCase__      		=			'''src/transformers'''


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


def 	_A  (					A__   ):






 """simple docstring"""



 if _re_test_backend.search(A__   ) is None:
  return None
 __lowercase													=				[b[0] for b in _re_backend.findall(A__   )]
 backends.sort()
 return "_and_".join(A__   )


def 	_A  (					A__   ):






 """simple docstring"""



 with open(A__  ,       '''r'''  ,       encoding='''utf-8'''  ,       newline='''\n'''   ) as f:
  __lowercase													=				f.readlines()

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

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

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

   __lowercase													=				objects
  else:
   line_index += 1

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

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

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

   __lowercase													=				objects
  else:
   line_index += 1

 return import_dict_objects, type_hint_objects


def 	_A  (					A__  ,       A__   ):






 """simple docstring"""



 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!"]

 __lowercase													=				[]
 for key in import_dict_objects.keys():
  __lowercase													=				find_duplicates(import_dict_objects[key]   )
  if duplicate_imports:
   errors.append(F"Duplicate _import_structure definitions for: {duplicate_imports}"   )
  __lowercase													=				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]   )   ):
   __lowercase													=				'''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 	_A  (					):






 """simple docstring"""



 __lowercase													=				[]
 for root, _, files in os.walk(A__   ):
  if "__init__.py" in files:
   __lowercase													=				os.path.join(A__  ,       '''__init__.py'''   )
   __lowercase													=				parse_init(A__   )
   if objects is not None:
    __lowercase													=				analyze_results(*A__   )
    if len(A__   ) > 0:
     __lowercase													=				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 	_A  (					):






 """simple docstring"""



 __lowercase													=				[]
 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
   __lowercase													=				str((Path(A__   ) / folder).relative_to(A__   )   )
   __lowercase													=				short_path.replace(os.path.sep  ,       '''.'''   )
   submodules.append(A__   )
  for fname in files:
   if fname == "__init__.py":
    continue
   __lowercase													=				str((Path(A__   ) / fname).relative_to(A__   )   )
   __lowercase													=				short_path.replace('''.py'''  ,       ''''''   ).replace(os.path.sep  ,       '''.'''   )
   if len(submodule.split('''.'''   )   ) == 1:
    submodules.append(A__   )
 return submodules


lowerCAmelCase__      		=			[
    '''convert_pytorch_checkpoint_to_tf2''',
    '''modeling_flax_pytorch_utils''',
    '''models.esm.openfold_utils''',
]


def 	_A  (					):






 """simple docstring"""



 from transformers.utils import direct_transformers_import

 __lowercase													=				direct_transformers_import(A__   )

 __lowercase													=				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(A__  ,       '''__init__.py'''   )  ,       '''r'''   ) as f:
  __lowercase													=				f.read()
 import_structure_keys.update(set(re.findall(R'''import_structure\[\"([^\"]*)\"\]'''  ,       A__   )   )   )

 __lowercase													=				[
     module
     for module in get_transformers_submodules()
     if module not in IGNORE_SUBMODULES and module not in import_structure_keys
 ]

 if len(A__   ) > 0:
  __lowercase													=				'''\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()




'''simple docstring'''






def 	_A  (					A__   ):






 """simple docstring"""



 if not nums:  # Makes sure that the list is not empty
  raise ValueError('''List is empty'''   )

 __lowercase													=				sum(A__   ) / len(A__   )  # Calculate the average
 return sum(abs(x - average   ) for x in nums   ) / len(A__   )


if __name__ == "__main__":
 import doctest

 doctest.testmod()

