



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


__snake_case       :	Dict            ='src/transformers'


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






def 			lowerCAmelCase__	(					lowerCamelCase_	:	Union[str, Any]):





    '''simple docstring'''

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






def 			lowerCAmelCase__	(					lowerCamelCase_	:	Any):





    '''simple docstring'''

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

    lowerCAmelCase__  :       Optional[int]				=  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
    lowerCAmelCase__  :       Dict				=  []
    while not lines[line_index].startswith('''if TYPE_CHECKING''') and find_backend(lines[line_index]) is None:
        lowerCAmelCase__  :       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_):
            lowerCAmelCase__  :       Optional[int]				=  _re_one_line_import_struct.search(lowerCamelCase_).groups()[0]
            lowerCAmelCase__  :       int				=  re.findall('''\[([^\]]+)\]''' ,lowerCamelCase_)
            for imp in imports:
                objects.extend([obj[1:-1] for obj in imp.split(''', ''')])
            line_index += 1
            continue
        lowerCAmelCase__  :       List[str]				=  _re_import_struct_key_value.search(lowerCamelCase_)
        if single_line_import_search is not None:
            lowerCAmelCase__  :       Optional[Any]				=  [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

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

            lowerCAmelCase__  :       Tuple				=  objects
        else:
            line_index += 1

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

    lowerCAmelCase__  :       Optional[int]				=  {'''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.
        lowerCAmelCase__  :       Dict				=  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__  :       Any				=  lines[line_index]
                lowerCAmelCase__  :       List[Any]				=  _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

            lowerCAmelCase__  :       Tuple				=  objects
        else:
            line_index += 1

    return import_dict_objects, type_hint_objects






def 			lowerCAmelCase__	(					lowerCamelCase_	:	List[Any] ,lowerCamelCase_	:	List[str]):





    '''simple docstring'''

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

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





    '''simple docstring'''

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





    '''simple docstring'''

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


__snake_case       :	List[Any]            =[
    'convert_pytorch_checkpoint_to_tf2',
    'modeling_flax_pytorch_utils',
]






def 			lowerCAmelCase__	(					):





    '''simple docstring'''

    lowerCAmelCase__  :       Optional[int]				=  importlib.util.spec_from_file_location(
        '''transformers''' ,os.path.join(lowerCamelCase_ ,'''__init__.py''') ,submodule_search_locations=[PATH_TO_TRANSFORMERS] ,)
    lowerCAmelCase__  :       Tuple				=  spec.loader.load_module()

    lowerCAmelCase__  :       List[str]				=  [
        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:
        lowerCAmelCase__  :       Optional[int]				=  '''\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()






from __future__ import annotations






def 			lowerCAmelCase__	(					lowerCamelCase_	:	list[int]):





				'''simple docstring'''

				return len(set(lowerCamelCase_)) == len(lowerCamelCase_)


if __name__ == "__main__":
							import doctest

							doctest.testmod()

