


'''simple docstring'''


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


_UpperCamelCase 							=  """src/transformers"""


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


def 		_lowercase (SCREAMING_SNAKE_CASE							):




     '''simple docstring'''





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


def 		_lowercase (SCREAMING_SNAKE_CASE							):




     '''simple docstring'''





     with open(SCREAMING_SNAKE_CASE       ,					"r"       ,					encoding="utf-8"       ,					newline="\n"							) as f:
          __A	:       Tuple      =							f.readlines()

     __A	:       List[str]      =							0
     while line_index < len(SCREAMING_SNAKE_CASE							) and not lines[line_index].startswith("_import_structure = {"							):
          line_index += 1

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

     # First grab the objects without a specific backend in _import_structure
     __A	:       str      =							[]
     while not lines[line_index].startswith("if TYPE_CHECKING"							) and find_backend(lines[line_index]							) is None:
          __A	:       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(SCREAMING_SNAKE_CASE							):
               __A	:       Optional[int]      =							_re_one_line_import_struct.search(SCREAMING_SNAKE_CASE							).groups()[0]
               __A	:       Tuple      =							re.findall("\[([^\]]+)\]"       ,					SCREAMING_SNAKE_CASE							)
               for imp in imports:
                    objects.extend([obj[1:-1] for obj in imp.split(", "							)]							)
               line_index += 1
               continue
          __A	:       Dict      =							_re_import_struct_key_value.search(SCREAMING_SNAKE_CASE							)
          if single_line_import_search is not None:
               __A	:       Dict      =							[obj[1:-1] for obj in single_line_import_search.groups()[0].split(", "							) if len(SCREAMING_SNAKE_CASE							) > 0]
               objects.extend(SCREAMING_SNAKE_CASE							)
          elif line.startswith(" " * 8 + "\""							):
               objects.append(line[9:-3]							)
          line_index += 1

     __A	:       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.
          __A	:       str      =							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	:       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

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

               __A	:       str      =							objects
          else:
               line_index += 1

    # At this stage we are in the TYPE_CHECKING part, first grab the objects without a specific backend
     __A	:       List[Any]      =							[]
     while (
         line_index < len(SCREAMING_SNAKE_CASE							)
         and find_backend(lines[line_index]							) is None
         and not lines[line_index].startswith("else"							)
     ):
          __A	:       Union[str, Any]      =							lines[line_index]
          __A	:       str      =							_re_import.search(SCREAMING_SNAKE_CASE							)
          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	:       int      =							{"none": objects}
     # Let's continue with backend-specific objects
     while line_index < len(SCREAMING_SNAKE_CASE							):
          # If the line is an if is_backend_available, we grab all objects associated.
          __A	:       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:
               __A	:       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

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

     return import_dict_objects, type_hint_objects


def 		_lowercase (SCREAMING_SNAKE_CASE       ,					SCREAMING_SNAKE_CASE							):




     '''simple docstring'''





     def find_duplicates(SCREAMING_SNAKE_CASE							):
          return [k for k, v in collections.Counter(SCREAMING_SNAKE_CASE							).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	:       str      =							[]
     for key in import_dict_objects.keys():
          __A	:       Any      =							find_duplicates(import_dict_objects[key]							)
          if duplicate_imports:
               errors.append(f"Duplicate _import_structure definitions for: {duplicate_imports}"							)
          __A	:       Tuple      =							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	:       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 		_lowercase ():




     '''simple docstring'''





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


def 		_lowercase ():




     '''simple docstring'''





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


_UpperCamelCase 							=  [
    """convert_pytorch_checkpoint_to_tf2""",
    """modeling_flax_pytorch_utils""",
]


def 		_lowercase ():




     '''simple docstring'''





     __A	:       Tuple      =							importlib.util.spec_from_file_location(
         "transformers"       ,					os.path.join(SCREAMING_SNAKE_CASE       ,					"__init__.py"							)       ,					submodule_search_locations=[PATH_TO_TRANSFORMERS]       ,					)
     __A	:       List[str]      =							spec.loader.load_module()

     __A	:       Any      =							[
         module
         for module in get_transformers_submodules()
         if module not in IGNORE_SUBMODULES and module not in transformers._import_structure.keys()
     ]
     if len(SCREAMING_SNAKE_CASE							) > 0:
          __A	:       str      =							"\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()





'''simple docstring'''


from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_torch_available,
    is_vision_available,
)


_UpperCamelCase 							=  {"""configuration_vit""": ["""VIT_PRETRAINED_CONFIG_ARCHIVE_MAP""", """ViTConfig""", """ViTOnnxConfig"""]}

try:
      if not is_vision_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      _UpperCamelCase 							=  ["""ViTFeatureExtractor"""]
      _UpperCamelCase 							=  ["""ViTImageProcessor"""]

try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      _UpperCamelCase 							=  [
          """VIT_PRETRAINED_MODEL_ARCHIVE_LIST""",
          """ViTForImageClassification""",
          """ViTForMaskedImageModeling""",
          """ViTModel""",
          """ViTPreTrainedModel""",
      ]

try:
      if not is_tf_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      _UpperCamelCase 							=  [
          """TFViTForImageClassification""",
          """TFViTModel""",
          """TFViTPreTrainedModel""",
      ]

try:
      if not is_flax_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      _UpperCamelCase 							=  [
          """FlaxViTForImageClassification""",
          """FlaxViTModel""",
          """FlaxViTPreTrainedModel""",
      ]

if TYPE_CHECKING:
      from .configuration_vit import VIT_PRETRAINED_CONFIG_ARCHIVE_MAP, ViTConfig, ViTOnnxConfig

      try:
            if not is_vision_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .feature_extraction_vit import ViTFeatureExtractor
            from .image_processing_vit import ViTImageProcessor

      try:
            if not is_torch_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_vit import (
                VIT_PRETRAINED_MODEL_ARCHIVE_LIST,
                ViTForImageClassification,
                ViTForMaskedImageModeling,
                ViTModel,
                ViTPreTrainedModel,
            )

      try:
            if not is_tf_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_tf_vit import TFViTForImageClassification, TFViTModel, TFViTPreTrainedModel

      try:
            if not is_flax_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_flax_vit import FlaxViTForImageClassification, FlaxViTModel, FlaxViTPreTrainedModel


else:
      import sys

      _UpperCamelCase 							=  _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)

