





import collections
import os
import re
from pathlib import Path


_UpperCAmelCase							:			Optional[Any]        =							"""src/transformers"""


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


def 			SCREAMING_SNAKE_CASE (			_UpperCAmelCase					)     ->	Union[str, Any]:
    if _re_test_backend.search(_UpperCAmelCase					) is None:
        return None
    lowerCamelCase__       : Tuple   					=						[b[0] for b in _re_backend.findall(_UpperCAmelCase					)]
    backends.sort()
    return "_and_".join(_UpperCAmelCase					)


def 			SCREAMING_SNAKE_CASE (			_UpperCAmelCase					)     ->	Union[str, Any]:
    with open(_UpperCAmelCase		,      'r'		,      encoding='utf-8'		,      newline='\n'					) as f:
        lowerCamelCase__       : Optional[Any]   					=						f.readlines()

    lowerCamelCase__       : str   					=						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__       : int   					=						[]
    while not lines[line_index].startswith('if TYPE_CHECKING'					) and find_backend(lines[line_index]					) is None:
        lowerCamelCase__       : Optional[int]   					=						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__       : int   					=						_re_one_line_import_struct.search(_UpperCAmelCase					).groups()[0]
            lowerCamelCase__       : int   					=						re.findall(r'\[([^\]]+)\]'		,      _UpperCAmelCase					)
            for imp in imports:
                objects.extend([obj[1:-1] for obj in imp.split(', '					)]					)
            line_index += 1
            continue
        lowerCamelCase__       : Optional[Any]   					=						_re_import_struct_key_value.search(_UpperCAmelCase					)
        if single_line_import_search is not None:
            lowerCamelCase__       : Optional[int]   					=						[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__       : Union[str, 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__       : Dict   					=						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__       : int   					=						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__       : List[str]   					=						_re_import_struct_add_many.search(_UpperCAmelCase					).groups()[0].split(', '					)
                    lowerCamelCase__       : 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__       : Any   					=						_re_between_brackets.search(_UpperCAmelCase					).groups()[0].split(', '					)
                    lowerCamelCase__       : Optional[Any]   					=						[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__       : Dict   					=						[]
    while (
        line_index < len(_UpperCAmelCase					)
        and find_backend(lines[line_index]					) is None
        and not lines[line_index].startswith('else'					)
    ):
        lowerCamelCase__       : Dict   					=						lines[line_index]
        lowerCamelCase__       : Dict   					=						_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__       : Tuple   					=						{'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__       : 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__       : 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__       : Optional[int]   					=						[]
            # Until we unindent, add backend objects to the list
            while len(lines[line_index]					) <= 1 or lines[line_index].startswith(' ' * 8					):
                lowerCamelCase__       : Dict   					=						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__       : int   					=						objects
        else:
            line_index += 1

    return import_dict_objects, type_hint_objects


def 			SCREAMING_SNAKE_CASE (			_UpperCAmelCase		,      _UpperCAmelCase					)     ->	List[str]:

    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__       : List[str]   					=						[]
    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__       : int   					=						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__       : Union[str, 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 			SCREAMING_SNAKE_CASE (			)     ->	Any:
    lowerCamelCase__       : int   					=						[]
    for root, _, files in os.walk(_UpperCAmelCase					):
        if "__init__.py" in files:
            lowerCamelCase__       : List[str]   					=						os.path.join(_UpperCAmelCase		,      '__init__.py'					)
            lowerCamelCase__       : List[str]   					=						parse_init(_UpperCAmelCase					)
            if objects is not None:
                lowerCamelCase__       : Any   					=						analyze_results(*_UpperCAmelCase					)
                if len(_UpperCAmelCase					) > 0:
                    lowerCamelCase__       : List[str]   					=						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 			SCREAMING_SNAKE_CASE (			)     ->	Optional[Any]:
    lowerCamelCase__       : Dict   					=						[]
    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__       : Union[str, Any]   					=						str((Path(_UpperCAmelCase					) / folder).relative_to(_UpperCAmelCase					)					)
            lowerCamelCase__       : Union[str, Any]   					=						short_path.replace(os.path.sep		,      '.'					)
            submodules.append(_UpperCAmelCase					)
        for fname in files:
            if fname == "__init__.py":
                continue
            lowerCamelCase__       : Optional[Any]   					=						str((Path(_UpperCAmelCase					) / fname).relative_to(_UpperCAmelCase					)					)
            lowerCamelCase__       : Optional[int]   					=						short_path.replace('.py'		,      ''					).replace(os.path.sep		,      '.'					)
            if len(submodule.split('.'					)					) == 1:
                submodules.append(_UpperCAmelCase					)
    return submodules


_UpperCAmelCase							:			int        =							[
    """convert_pytorch_checkpoint_to_tf2""",
    """modeling_flax_pytorch_utils""",
    """models.esm.openfold_utils""",
]


def 			SCREAMING_SNAKE_CASE (			)     ->	Optional[int]:
    # This is to make sure the transformers module imported is the one in the repo.
    from transformers.utils import direct_transformers_import

    lowerCamelCase__       : Tuple   					=						direct_transformers_import(_UpperCAmelCase					)

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

    lowerCamelCase__       : Optional[int]   					=						[
        module
        for module in get_transformers_submodules()
        if module not in IGNORE_SUBMODULES and module not in import_structure_keys
    ]

    if len(_UpperCAmelCase					) > 0:
        lowerCamelCase__       : Optional[int]   					=						'\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()












from typing import List

from ...configuration_utils import PretrainedConfig
from ...utils import logging


_UpperCAmelCase							:			Any        =							logging.get_logger(__name__)

_UpperCAmelCase							:			Union[str, Any]        =							{
    """snap-research/efficientformer-l1-300""": (
        """https://huggingface.co/snap-research/efficientformer-l1-300/resolve/main/config.json"""
    ),
}

class   lowerCAmelCase				(   __UpperCamelCase     ):
 UpperCAmelCase__						=						"""efficientformer"""
 def __init__( self    : Dict     ,	UpperCAmelCase    : List[int] = [3, 2, 6, 4]     ,	UpperCAmelCase    : List[int] = [48, 96, 224, 448]     ,	UpperCAmelCase    : List[bool] = [True, True, True, True]     ,	UpperCAmelCase    : int = 448     ,	UpperCAmelCase    : int = 32     ,	UpperCAmelCase    : int = 4     ,	UpperCAmelCase    : int = 7     ,	UpperCAmelCase    : int = 5     ,	UpperCAmelCase    : int = 8     ,	UpperCAmelCase    : int = 4     ,	UpperCAmelCase    : float = 0.0     ,	UpperCAmelCase    : int = 16     ,	UpperCAmelCase    : int = 3     ,	UpperCAmelCase    : int = 3     ,	UpperCAmelCase    : int = 3     ,	UpperCAmelCase    : int = 2     ,	UpperCAmelCase    : int = 1     ,	UpperCAmelCase    : float = 0.0     ,	UpperCAmelCase    : int = 1     ,	UpperCAmelCase    : bool = True     ,	UpperCAmelCase    : bool = True     ,	UpperCAmelCase    : float = 1e-5     ,	UpperCAmelCase    : str = "gelu"     ,	UpperCAmelCase    : float = 0.0_2     ,	UpperCAmelCase    : float = 1e-12     ,	UpperCAmelCase    : int = 224     ,	UpperCAmelCase    : float = 1e-05     ,	**UpperCAmelCase    : Tuple     ,	)     ->      None:
     super().__init__(**UpperCAmelCase      )

     lowerCamelCase__       : Optional[Any]   					=						hidden_act
     lowerCamelCase__       : int   					=						hidden_dropout_prob
     lowerCamelCase__       : List[Any]   					=						hidden_sizes
     lowerCamelCase__       : int   					=						num_hidden_layers
     lowerCamelCase__       : int   					=						num_attention_heads
     lowerCamelCase__       : Dict   					=						initializer_range
     lowerCamelCase__       : Optional[Any]   					=						layer_norm_eps
     lowerCamelCase__       : int   					=						patch_size
     lowerCamelCase__       : List[Any]   					=						num_channels
     lowerCamelCase__       : List[str]   					=						depths
     lowerCamelCase__       : Any   					=						mlp_expansion_ratio
     lowerCamelCase__       : Any   					=						downsamples
     lowerCamelCase__       : str   					=						dim
     lowerCamelCase__       : Tuple   					=						key_dim
     lowerCamelCase__       : int   					=						attention_ratio
     lowerCamelCase__       : int   					=						resolution
     lowerCamelCase__       : Dict   					=						pool_size
     lowerCamelCase__       : List[str]   					=						downsample_patch_size
     lowerCamelCase__       : Tuple   					=						downsample_stride
     lowerCamelCase__       : int   					=						downsample_pad
     lowerCamelCase__       : Optional[int]   					=						drop_path_rate
     lowerCamelCase__       : Optional[Any]   					=						num_metaad_blocks
     lowerCamelCase__       : Any   					=						distillation
     lowerCamelCase__       : Optional[int]   					=						use_layer_scale
     lowerCamelCase__       : Union[str, Any]   					=						layer_scale_init_value
     lowerCamelCase__       : Optional[int]   					=						image_size
     lowerCamelCase__       : Optional[Any]   					=						batch_norm_eps





