




import collections
import importlib.util
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("""^\s+\"([^\"]+)\",""")
# Catches a line with objects between brackets only:    ["foo", "bar"],
lowerCAmelCase_					    = re.compile("""^\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      __lowerCAmelCase			(					UpperCamelCase      )     ->	List[str]:







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



def      __lowerCAmelCase			(					UpperCamelCase      )     ->	str:







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

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

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

  # First grab the objects without a specific backend in _import_structure
  lowerCAmelCase__				:  Union[str, Any]		       =     []
  while not lines[line_index].startswith('''if TYPE_CHECKING'''      ) and find_backend(lines[line_index]      ) is None:
    lowerCAmelCase__				:  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(__UpperCamelCase      ):
      lowerCAmelCase__				:  Dict		       =     _re_one_line_import_struct.search(__UpperCamelCase      ).groups()[0]
      lowerCAmelCase__				:  str		       =     re.findall('''\[([^\]]+)\]'''	,      __UpperCamelCase      )
      for imp in imports:
        objects.extend([obj[1:-1] for obj in imp.split(''', '''      )]      )
      line_index += 1
      continue
    lowerCAmelCase__				:  Union[str, Any]		       =     _re_import_struct_key_value.search(__UpperCamelCase      )
    if single_line_import_search is not None:
      lowerCAmelCase__				:  Union[str, Any]		       =     [obj[1:-1] for obj in single_line_import_search.groups()[0].split(''', '''      ) if len(__UpperCamelCase      ) > 0]
      objects.extend(__UpperCamelCase      )
    elif line.startswith(''' ''' * 8 + '''"'''      ):
      objects.append(line[9:-3]      )
    line_index += 1

  lowerCAmelCase__				:  List[Any]		       =     {'''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__				:  Union[str, Any]		       =     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__				:  Optional[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

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

      lowerCAmelCase__				:  Any		       =     objects
    else:
      line_index += 1

    # At this stage we are in the TYPE_CHECKING part, first grab the objects without a specific backend
  lowerCAmelCase__				:  Union[str, Any]		       =     []
  while (
      line_index < len(__UpperCamelCase      )
      and find_backend(lines[line_index]      ) is None
      and not lines[line_index].startswith('''else'''      )
  ):
    lowerCAmelCase__				:  Optional[int]		       =     lines[line_index]
    lowerCAmelCase__				:  Union[str, Any]		       =     _re_import.search(__UpperCamelCase      )
    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__				:  str		       =     {'''none''': objects}
  # Let's continue with backend-specific objects
  while line_index < len(__UpperCamelCase      ):
    # If the line is an if is_backend_available, we grab all objects associated.
    lowerCAmelCase__				:  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:
      lowerCAmelCase__				:  Optional[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

      lowerCAmelCase__				:  Optional[Any]		       =     []
      # Until we unindent, add backend objects to the list
      while len(lines[line_index]      ) <= 1 or lines[line_index].startswith(''' ''' * 8      ):
        lowerCAmelCase__				:  Tuple		       =     lines[line_index]
        lowerCAmelCase__				:  Optional[Any]		       =     _re_import.search(__UpperCamelCase      )
        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__				:  List[str]		       =     objects
    else:
      line_index += 1

  return import_dict_objects, type_hint_objects



def      __lowerCAmelCase			(					UpperCamelCase	,      UpperCamelCase      )     ->	int:







  def find_duplicates(UpperCamelCase      ):
    return [k for k, v in collections.Counter(__UpperCamelCase      ).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__				:  Any		       =     []
  for key in import_dict_objects.keys():
    lowerCAmelCase__				:  Optional[int]		       =     find_duplicates(import_dict_objects[key]      )
    if duplicate_imports:
      errors.append(F"""Duplicate _import_structure definitions for: {duplicate_imports}"""      )
    lowerCAmelCase__				:  Union[str, Any]		       =     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__				:  List[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      __lowerCAmelCase			(					)     ->	Optional[int]:
  lowerCAmelCase__				:  List[Any]		       =     []
  for root, _, files in os.walk(__UpperCamelCase      ):
    if "__init__.py" in files:
      lowerCAmelCase__				:  Tuple		       =     os.path.join(__UpperCamelCase	,      '''__init__.py'''      )
      lowerCAmelCase__				:  str		       =     parse_init(__UpperCamelCase      )
      if objects is not None:
        lowerCAmelCase__				:  int		       =     analyze_results(*__UpperCamelCase      )
        if len(__UpperCamelCase      ) > 0:
          lowerCAmelCase__				:  Any		       =     F"""Problem in {fname}, both halves do not define the same objects.\n{errors[0]}"""
          failures.append('''\n'''.join(__UpperCamelCase      )      )
  if len(__UpperCamelCase      ) > 0:
    raise ValueError('''\n\n'''.join(__UpperCamelCase      )      )



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


lowerCAmelCase_					    = [
    'convert_pytorch_checkpoint_to_tf2',
    'modeling_flax_pytorch_utils',
]



def      __lowerCAmelCase			(					)     ->	str:
  lowerCAmelCase__				:  List[Any]		       =     importlib.util.spec_from_file_location(
      '''transformers'''	,      os.path.join(__UpperCamelCase	,      '''__init__.py'''      )	,      submodule_search_locations=[PATH_TO_TRANSFORMERS]	,      )
  lowerCAmelCase__				:  Optional[Any]		       =     spec.loader.load_module()

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







def      __lowerCAmelCase			(					UpperCamelCase      )     ->	bool:
  if not isinstance(UpperCamelCase	,      UpperCamelCase      ):
    raise ValueError('''Input series is not valid, valid series - [2, 4, 6]'''      )
  if len(UpperCamelCase      ) == 0:
    raise ValueError('''Input list must be a non empty list'''      )
  if len(UpperCamelCase      ) == 1:
    return True
  lowerCAmelCase__				:  Tuple		       =     series[1] - series[0]
  for index in range(len(UpperCamelCase      ) - 1      ):
    if series[index + 1] - series[index] != common_diff:
      return False
  return True



def      __lowerCAmelCase			(					UpperCamelCase      )     ->	float:
  if not isinstance(UpperCamelCase	,      UpperCamelCase      ):
    raise ValueError('''Input series is not valid, valid series - [2, 4, 6]'''      )
  if len(UpperCamelCase      ) == 0:
    raise ValueError('''Input list must be a non empty list'''      )
  lowerCAmelCase__				:  int		       =     0
  for val in series:
    answer += val
  return answer / len(UpperCamelCase      )


if __name__ == "__main__":
     import doctest

     doctest.testmod()

