
"""simple docstring"""







import collections
import os
import re
from pathlib import Path


lowercase_         =       "src/transformers"


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




def       A_      (       lowercase   )  ->				List[str]:


     """simple docstring"""







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




def       A_      (       lowercase   )  ->				Optional[int]:


     """simple docstring"""







     with open(lowercase    ,			"""r"""    ,			encoding="""utf-8"""    ,			newline="""\n"""   ) as f:
          UpperCAmelCase_    :     str            =	f.readlines()

     UpperCAmelCase_    :     List[Any]            =	0
     while line_index < len(lowercase   ) and not lines[line_index].startswith("""_import_structure = {"""   ):
          line_index += 1

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

     # First grab the objects without a specific backend in _import_structure
     UpperCAmelCase_    :     Tuple            =	[]
     while not lines[line_index].startswith("""if TYPE_CHECKING"""   ) and find_backend(lines[line_index]   ) is None:
          UpperCAmelCase_    :     List[Any]            =	lines[line_index]
          # If we have everything on a single line, let's deal with it.
          if _re_one_line_import_struct.search(lowercase   ):
               UpperCAmelCase_    :     Any            =	_re_one_line_import_struct.search(lowercase   ).groups()[0]
               UpperCAmelCase_    :     List[Any]            =	re.findall(R"""\[([^\]]+)\]"""    ,			lowercase   )
               for imp in imports:
                    objects.extend([obj[1:-1] for obj in imp.split(""", """   )]   )
               line_index += 1
               continue
          UpperCAmelCase_    :     List[Any]            =	_re_import_struct_key_value.search(lowercase   )
          if single_line_import_search is not None:
               UpperCAmelCase_    :     Optional[int]            =	[obj[1:-1] for obj in single_line_import_search.groups()[0].split(""", """   ) if len(lowercase   ) > 0]
               objects.extend(lowercase   )
          elif line.startswith(""" """ * 8 + """\""""   ):
               objects.append(line[9:-3]   )
          line_index += 1

     UpperCAmelCase_    :     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.
          UpperCAmelCase_    :     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:
               UpperCAmelCase_    :     List[str]            =	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

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

               UpperCAmelCase_    :     List[Any]            =	objects
          else:
               line_index += 1

    # At this stage we are in the TYPE_CHECKING part, first grab the objects without a specific backend
     UpperCAmelCase_    :     Optional[Any]            =	[]
     while (
         line_index < len(lowercase   )
         and find_backend(lines[line_index]   ) is None
         and not lines[line_index].startswith("""else"""   )
     ):
          UpperCAmelCase_    :     Any            =	lines[line_index]
          UpperCAmelCase_    :     str            =	_re_import.search(lowercase   )
          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

     UpperCAmelCase_    :     List[Any]            =	{"""none""": objects}
     # Let's continue with backend-specific objects
     while line_index < len(lowercase   ):
          # If the line is an if is_backend_available, we grab all objects associated.
          UpperCAmelCase_    :     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:
               UpperCAmelCase_    :     Optional[int]            =	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

               UpperCAmelCase_    :     int            =	[]
               # Until we unindent, add backend objects to the list
               while len(lines[line_index]   ) <= 1 or lines[line_index].startswith(""" """ * 8   ):
                    UpperCAmelCase_    :     Optional[int]            =	lines[line_index]
                    UpperCAmelCase_    :     str            =	_re_import.search(lowercase   )
                    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

               UpperCAmelCase_    :     Dict            =	objects
          else:
               line_index += 1

     return import_dict_objects, type_hint_objects




def       A_      (       lowercase    ,			lowercase   )  ->				List[str]:


     """simple docstring"""







     def find_duplicates(lowercase   ):
          return [k for k, v in collections.Counter(lowercase   ).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!"]

     UpperCAmelCase_    :     Dict            =	[]
     for key in import_dict_objects.keys():
          UpperCAmelCase_    :     str            =	find_duplicates(import_dict_objects[key]   )
          if duplicate_imports:
               errors.append(f'''Duplicate _import_structure definitions for: {duplicate_imports}'''   )
          UpperCAmelCase_    :     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]   )   ):
               UpperCAmelCase_    :     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       A_      (       )  ->				Union[str, Any]:


     """simple docstring"""







     UpperCAmelCase_    :     Dict            =	[]
     for root, _, files in os.walk(lowercase   ):
          if "__init__.py" in files:
               UpperCAmelCase_    :     int            =	os.path.join(lowercase    ,			"""__init__.py"""   )
               UpperCAmelCase_    :     List[str]            =	parse_init(lowercase   )
               if objects is not None:
                    UpperCAmelCase_    :     Dict            =	analyze_results(*lowercase   )
                    if len(lowercase   ) > 0:
                         UpperCAmelCase_    :     Union[str, Any]            =	f'''Problem in {fname}, both halves do not define the same objects.\n{errors[0]}'''
                         failures.append("""\n""".join(lowercase   )   )
     if len(lowercase   ) > 0:
          raise ValueError("""\n\n""".join(lowercase   )   )




def       A_      (       )  ->				Dict:


     """simple docstring"""







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


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




def       A_      (       )  ->				Optional[Any]:


     """simple docstring"""







     from transformers.utils import direct_transformers_import

     UpperCAmelCase_    :     List[Any]            =	direct_transformers_import(lowercase   )

     UpperCAmelCase_    :     Union[str, Any]            =	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(lowercase    ,			"""__init__.py"""   )    ,			"""r"""   ) as f:
          UpperCAmelCase_    :     List[str]            =	f.read()
     import_structure_keys.update(set(re.findall(R"""import_structure\[\"([^\"]*)\"\]"""    ,			lowercase   )   )   )

     UpperCAmelCase_    :     List[str]            =	[
         module
         for module in get_transformers_submodules()
         if module not in IGNORE_SUBMODULES and module not in import_structure_keys
     ]

     if len(lowercase   ) > 0:
          UpperCAmelCase_    :     Union[str, Any]            =	"""\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()



"""simple docstring"""







from . import __version__

# Backward compatibility imports, to make sure all those objects can be found in file_utils
from .utils import (
    CLOUDFRONT_DISTRIB_PREFIX,
    CONFIG_NAME,
    DISABLE_TELEMETRY,
    DUMMY_INPUTS,
    DUMMY_MASK,
    ENV_VARS_TRUE_AND_AUTO_VALUES,
    ENV_VARS_TRUE_VALUES,
    FEATURE_EXTRACTOR_NAME,
    FLAX_WEIGHTS_NAME,
    HF_MODULES_CACHE,
    HUGGINGFACE_CO_PREFIX,
    HUGGINGFACE_CO_RESOLVE_ENDPOINT,
    MODEL_CARD_NAME,
    MULTIPLE_CHOICE_DUMMY_INPUTS,
    PYTORCH_PRETRAINED_BERT_CACHE,
    PYTORCH_TRANSFORMERS_CACHE,
    S3_BUCKET_PREFIX,
    SENTENCEPIECE_UNDERLINE,
    SPIECE_UNDERLINE,
    TF2_WEIGHTS_NAME,
    TF_WEIGHTS_NAME,
    TORCH_FX_REQUIRED_VERSION,
    TRANSFORMERS_CACHE,
    TRANSFORMERS_DYNAMIC_MODULE_NAME,
    USE_JAX,
    USE_TF,
    USE_TORCH,
    WEIGHTS_INDEX_NAME,
    WEIGHTS_NAME,
    ContextManagers,
    DummyObject,
    EntryNotFoundError,
    ExplicitEnum,
    ModelOutput,
    PaddingStrategy,
    PushToHubMixin,
    RepositoryNotFoundError,
    RevisionNotFoundError,
    TensorType,
    _LazyModule,
    add_code_sample_docstrings,
    add_end_docstrings,
    add_start_docstrings,
    add_start_docstrings_to_model_forward,
    cached_property,
    copy_func,
    default_cache_path,
    define_sagemaker_information,
    get_cached_models,
    get_file_from_repo,
    get_full_repo_name,
    get_torch_version,
    has_file,
    http_user_agent,
    is_apex_available,
    is_bsa_available,
    is_coloredlogs_available,
    is_datasets_available,
    is_detectrona_available,
    is_faiss_available,
    is_flax_available,
    is_ftfy_available,
    is_in_notebook,
    is_ipex_available,
    is_librosa_available,
    is_offline_mode,
    is_onnx_available,
    is_pandas_available,
    is_phonemizer_available,
    is_protobuf_available,
    is_psutil_available,
    is_pyanvml_available,
    is_pyctcdecode_available,
    is_pytesseract_available,
    is_pytorch_quantization_available,
    is_rjieba_available,
    is_sagemaker_dp_enabled,
    is_sagemaker_mp_enabled,
    is_scipy_available,
    is_sentencepiece_available,
    is_seqio_available,
    is_sklearn_available,
    is_soundfile_availble,
    is_spacy_available,
    is_speech_available,
    is_tensor,
    is_tensorflow_probability_available,
    is_tfaonnx_available,
    is_tf_available,
    is_timm_available,
    is_tokenizers_available,
    is_torch_available,
    is_torch_bfaa_available,
    is_torch_cuda_available,
    is_torch_fx_available,
    is_torch_fx_proxy,
    is_torch_mps_available,
    is_torch_tfaa_available,
    is_torch_tpu_available,
    is_torchaudio_available,
    is_training_run_on_sagemaker,
    is_vision_available,
    replace_return_docstrings,
    requires_backends,
    to_numpy,
    to_py_obj,
    torch_only_method,
)

