


import argparse
import os
import re


# All paths are set with the intent you should run this script from the root of the repo with the command
# python utils/check_dummies.py
__UpperCAmelCase			:			Tuple			      =					"src/transformers"

# Matches is_xxx_available()
__UpperCAmelCase			:			int			      =					re.compile(r"is\_([a-z_]*)_available()")
# Matches from xxx import bla
__UpperCAmelCase			:			Union[str, Any]			      =					re.compile(r"\s+from\s+\S*\s+import\s+([^\(\s].*)\n")
__UpperCAmelCase			:			Tuple			      =					re.compile(r"^\s+if\s+not\s+\(?is\_[a-z_]*\_available\(\)")


__UpperCAmelCase			:			Union[str, Any]			      =					"\n{0} = None\n"

__UpperCAmelCase			:			Tuple			      =					"\nclass {0}(metaclass=DummyObject):\n    _backends = {1}\n\n    def __init__(self, *args, **kwargs):\n        requires_backends(self, {1})\n"


__UpperCAmelCase			:			Tuple			      =					"\ndef {0}(*args, **kwargs):\n    requires_backends({0}, {1})\n"


def   a						(				SCREAMING_SNAKE_CASE_   :		Optional[int]							):






       """simple docstring"""





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


def   a						(				):






       """simple docstring"""





       with open(os.path.join(SCREAMING_SNAKE_CASE_				,      '''__init__.py'''							)				,      '''r'''				,      encoding='''utf-8'''				,      newline='''\n'''							) as f:
              UpperCamelCase     :						str 						=		f.readlines()

       # Get to the point we do the actual imports for type checking
       UpperCamelCase     :						str 						=		0
       while not lines[line_index].startswith('''if TYPE_CHECKING'''							):
              line_index += 1

       UpperCamelCase     :						Union[str, Any] 						=		{}
       # Go through the end of the file
       while line_index < len(SCREAMING_SNAKE_CASE_							):
              # If the line is an if is_backend_available, we grab all objects associated.
              UpperCamelCase     :						Tuple 						=		find_backend(lines[line_index]							)
              if backend is not None:
                     while not lines[line_index].startswith('''    else:'''							):
                            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(''' ''' * 8							):
                            UpperCamelCase     :						List[Any] 						=		lines[line_index]
                            UpperCamelCase     :						List[Any] 						=		_re_single_line_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(''' ''' * 1_2							):
                                   objects.append(line[1_2:-2]							)
                            line_index += 1

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

       return backend_specific_objects


def   a						(				SCREAMING_SNAKE_CASE_   :		int				,      SCREAMING_SNAKE_CASE_   :		int							):






       """simple docstring"""





       if name.isupper():
              return DUMMY_CONSTANT.format(SCREAMING_SNAKE_CASE_							)
       elif name.islower():
              return DUMMY_FUNCTION.format(SCREAMING_SNAKE_CASE_				,      SCREAMING_SNAKE_CASE_							)
       else:
              return DUMMY_CLASS.format(SCREAMING_SNAKE_CASE_				,      SCREAMING_SNAKE_CASE_							)


def   a						(				SCREAMING_SNAKE_CASE_   :		Optional[int]=None							):






       """simple docstring"""





       if backend_specific_objects is None:
              UpperCamelCase     :						Tuple 						=		read_init()
       # For special correspondence backend to module name as used in the function requires_modulename
       UpperCamelCase     :						List[str] 						=		{}

       for backend, objects in backend_specific_objects.items():
              UpperCamelCase     :						Optional[int] 						=		'''[''' + ''', '''.join(F"""\"{b}\"""" for b in backend.split('''_and_'''							)							) + ''']'''
              UpperCamelCase     :						Tuple 						=		'''# This file is autogenerated by the command `make fix-copies`, do not edit.\n'''
              dummy_file += "from ..utils import DummyObject, requires_backends\n\n"
              dummy_file += "\n".join([create_dummy_object(SCREAMING_SNAKE_CASE_				,      SCREAMING_SNAKE_CASE_							) for o in objects]							)
              UpperCamelCase     :						Optional[Any] 						=		dummy_file

       return dummy_files


def   a						(				SCREAMING_SNAKE_CASE_   :		int=False							):






       """simple docstring"""





       UpperCamelCase     :						List[str] 						=		create_dummy_files()
       # For special correspondence backend to shortcut as used in utils/dummy_xxx_objects.py
       UpperCamelCase     :						Optional[Any] 						=		{'''torch''': '''pt'''}

       # Locate actual dummy modules and read their content.
       UpperCamelCase     :						Optional[int] 						=		os.path.join(SCREAMING_SNAKE_CASE_				,      '''utils'''							)
       UpperCamelCase     :						Union[str, Any] 						=		{
           backend: os.path.join(SCREAMING_SNAKE_CASE_				,      F"""dummy_{short_names.get(SCREAMING_SNAKE_CASE_				,      SCREAMING_SNAKE_CASE_							)}_objects.py"""							)
           for backend in dummy_files.keys()
       }

       UpperCamelCase     :						Dict 						=		{}
       for backend, file_path in dummy_file_paths.items():
              if os.path.isfile(SCREAMING_SNAKE_CASE_							):
                     with open(SCREAMING_SNAKE_CASE_				,      '''r'''				,      encoding='''utf-8'''				,      newline='''\n'''							) as f:
                            UpperCamelCase     :						int 						=		f.read()
              else:
                     UpperCamelCase     :						Any 						=		''''''

       for backend in dummy_files.keys():
              if dummy_files[backend] != actual_dummies[backend]:
                     if overwrite:
                            print(
                                F"""Updating transformers.utils.dummy_{short_names.get(SCREAMING_SNAKE_CASE_				,      SCREAMING_SNAKE_CASE_							)}_objects.py as the main """
                                '''__init__ has new objects.'''							)
                            with open(dummy_file_paths[backend]				,      '''w'''				,      encoding='''utf-8'''				,      newline='''\n'''							) as f:
                                   f.write(dummy_files[backend]							)
                     else:
                            raise ValueError(
                                '''The main __init__ has objects that are not present in '''
                                F"""transformers.utils.dummy_{short_names.get(SCREAMING_SNAKE_CASE_				,      SCREAMING_SNAKE_CASE_							)}_objects.py. Run `make fix-copies` """
                                '''to fix this.'''							)


if __name__ == "__main__":
  __UpperCAmelCase			:			Tuple			      =					argparse.ArgumentParser()
  parser.add_argument("--fix_and_overwrite", action="store_true", help="Whether to fix inconsistencies.")
  __UpperCAmelCase			:			str			      =					parser.parse_args()

  check_dummies(args.fix_and_overwrite)





from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


__UpperCAmelCase			:			int			      =					{"configuration_vilt": ["VILT_PRETRAINED_CONFIG_ARCHIVE_MAP", "ViltConfig"]}

try:
  if not is_vision_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  __UpperCAmelCase			:			Optional[Any]			      =					["ViltFeatureExtractor"]
  __UpperCAmelCase			:			Union[str, Any]			      =					["ViltImageProcessor"]
  __UpperCAmelCase			:			Dict			      =					["ViltProcessor"]

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  __UpperCAmelCase			:			List[Any]			      =					[
      "VILT_PRETRAINED_MODEL_ARCHIVE_LIST",
      "ViltForImageAndTextRetrieval",
      "ViltForImagesAndTextClassification",
      "ViltForTokenClassification",
      "ViltForMaskedLM",
      "ViltForQuestionAnswering",
      "ViltLayer",
      "ViltModel",
      "ViltPreTrainedModel",
  ]


if TYPE_CHECKING:
  from .configuration_vilt import VILT_PRETRAINED_CONFIG_ARCHIVE_MAP, ViltConfig

  try:
    if not is_vision_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .feature_extraction_vilt import ViltFeatureExtractor
    from .image_processing_vilt import ViltImageProcessor
    from .processing_vilt import ViltProcessor

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_vilt import (
        VILT_PRETRAINED_MODEL_ARCHIVE_LIST,
        ViltForImageAndTextRetrieval,
        ViltForImagesAndTextClassification,
        ViltForMaskedLM,
        ViltForQuestionAnswering,
        ViltForTokenClassification,
        ViltLayer,
        ViltModel,
        ViltPreTrainedModel,
    )


else:
  import sys

  __UpperCAmelCase			:			Any			      =					_LazyModule(__name__, globals()["__file__"], _import_structure)

