



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


__snake_case						:str						=					'''src/transformers'''


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





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





def 					__snake_case     (      _UpperCAmelCase    ):
    with open(_UpperCAmelCase       ,			'''r'''       ,			encoding='''utf-8'''       ,			newline='''\n'''    ) as f:
        __a							=    f.readlines()

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

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

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

            __a							=    objects
        else:
            line_index += 1

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

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

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

            __a							=    objects
        else:
            line_index += 1

    return import_dict_objects, type_hint_objects





def 					__snake_case     (      _UpperCAmelCase       ,			_UpperCAmelCase    ):

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

    __a							=    []
    for key in import_dict_objects.keys():
        __a							=    find_duplicates(import_dict_objects[key]    )
        if duplicate_imports:
            errors.append(f'Duplicate _import_structure definitions for: {duplicate_imports}'    )
        __a							=    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]    )    ):
            __a							=    '''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     (      ):
    __a							=    []
    for root, _, files in os.walk(_UpperCAmelCase    ):
        if "__init__.py" in files:
            __a							=    os.path.join(_UpperCAmelCase       ,			'''__init__.py'''    )
            __a							=    parse_init(_UpperCAmelCase    )
            if objects is not None:
                __a							=    analyze_results(*_UpperCAmelCase    )
                if len(_UpperCAmelCase    ) > 0:
                    __a							=    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 					__snake_case     (      ):
    __a							=    []
    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
            __a							=    str((Path(_UpperCAmelCase    ) / folder).relative_to(_UpperCAmelCase    )    )
            __a							=    short_path.replace(os.path.sep       ,			'''.'''    )
            submodules.append(_UpperCAmelCase    )
        for fname in files:
            if fname == "__init__.py":
                continue
            __a							=    str((Path(_UpperCAmelCase    ) / fname).relative_to(_UpperCAmelCase    )    )
            __a							=    short_path.replace('''.py'''       ,			''''''    ).replace(os.path.sep       ,			'''.'''    )
            if len(submodule.split('''.'''    )    ) == 1:
                submodules.append(_UpperCAmelCase    )
    return submodules


__snake_case						:Dict						=					[
    '''convert_pytorch_checkpoint_to_tf2''',
    '''modeling_flax_pytorch_utils''',
]





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

    __a							=    [
        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:
        __a							=    '''\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 					__snake_case     (      _UpperCAmelCase    ):
    if not isinstance(_UpperCAmelCase       ,			_UpperCAmelCase    ):
        raise TypeError('''Input value must be an \'int\' type'''    )

    __a							=    0
    while number:
        position += 1
        number >>= 1

    return position


if __name__ == "__main__":
 import doctest

 doctest.testmod()





