


"""simple docstring"""




import collections
import os
import re
from pathlib import Path


__SCREAMING_SNAKE_CASE      		=    """src/transformers"""


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



def     __a   (	a       ):





       """simple docstring"""







       if _re_test_backend.search(a       ) is None:
              return None
       _a							 =					[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:
              _a							 =					f.readlines()

       _a							 =					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
       _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(a       ):
                     _a							 =					_re_one_line_import_struct.search(a       ).groups()[0]
                     _a							 =					re.findall(R"\[([^\]]+)\]",		a       )
                     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(a       )
              if single_line_import_search is not None:
                     _a							 =					[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

       _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(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:
                                   _a							 =					_re_import_struct_add_many.search(a       ).groups()[0].split(", "       )
                                   _a							 =					[obj[1:-1] for obj in imports if len(a       ) > 0]
                                   objects.extend(a       )
                            elif _re_between_brackets.search(a       ) is not None:
                                   _a							 =					_re_between_brackets.search(a       ).groups()[0].split(", "       )
                                   _a							 =					[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(" " * 1_2 + "\""       ):
                                   objects.append(line[1_3:-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(a       )
           and find_backend(lines[line_index]       ) is None
           and not lines[line_index].startswith("else"       )
       ):
              _a							 =					lines[line_index]
              _a							 =					_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

       _a							 =					{"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.
              _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(a       )
                            if single_line_import_search is not None:
                                   objects.extend(single_line_import_search.groups()[0].split(", "       )       )
                            elif line.startswith(" " * 1_2       ):
                                   objects.append(line[1_2:-2]       )
                            line_index += 1

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

       _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     __a   (	):





       """simple docstring"""







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







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


__SCREAMING_SNAKE_CASE      		=    [
    """convert_pytorch_checkpoint_to_tf2""",
    """modeling_flax_pytorch_utils""",
    """models.esm.openfold_utils""",
]



def     __a   (	):





       """simple docstring"""







       from transformers.utils import direct_transformers_import

       _a							 =					direct_transformers_import(a       )

       _a							 =					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:
              _a							 =					f.read()
       import_structure_keys.update(set(re.findall(R"import_structure\[\"([^\"]*)\"\]",		a       )       )       )

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

       if len(a       ) > 0:
              _a							 =					"\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()



_lowerCAmelCase  :      int			 ="""
# Installazione di Transformers
! pip install transformers datasets
# Per installare dalla fonte invece dell'ultima versione rilasciata, commenta il comando sopra e
# rimuovi la modalità commento al comando seguente.
# ! pip install git+https://github.com/huggingface/transformers.git
"""

_lowerCAmelCase  :      List[str]			 =[{"""type""": """code""", """content""": INSTALL_CONTENT}]
_lowerCAmelCase  :      int			 ={
    """{processor_class}""": """FakeProcessorClass""",
    """{model_class}""": """FakeModelClass""",
    """{object_class}""": """FakeObjectClass""",
}