code: 
  
  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
  __A   :     Optional[int]      =			"src/transformers"
  
  # Matches is_xxx_available()
  __A   :     Tuple      =			re.compile(R'''is\_([a-z_]*)_available()''')
  # Matches from xxx import bla
  __A   :     Optional[int]      =			re.compile(R'''\s+from\s+\S*\s+import\s+([^\(\s].*)\n''')
  __A   :     int      =			re.compile(R'''^\s+if\s+not\s+\(?is\_[a-z_]*\_available\(\)''')
  
  
  __A   :     Any      =			"\n{0} = None\n"
  
  __A   :     int      =			"\nclass {0}(metaclass=DummyObject):\n    _backends = {1}\n\n    def __init__(self, *args, **kwargs):\n        requires_backends(self, {1})\n"
  
  
  __A   :     int      =			"\ndef {0}(*args, **kwargs):\n    requires_backends({0}, {1})\n"
  def 		SCREAMING_SNAKE_CASE__				(							_UpperCAmelCase				)					-> int:
  
  
  
      '''simple docstring'''
  
  
  
  
  
  
      if _re_test_backend.search(_UpperCAmelCase				) is None:
          return None
      lowerCAmelCase    			=      [b[0] for b in _re_backend.findall(_UpperCAmelCase				)]
      backends.sort()
      return "_and_".join(_UpperCAmelCase				)
  def 		SCREAMING_SNAKE_CASE__				(							)					-> List[Any]:
  
  
  
      '''simple docstring'''
  
  
  
  
  
  
      with open(os.path.join(_UpperCAmelCase,      '__init__.py'				),      'r',      encoding='utf-8',      newline='\n'				) as f:
          lowerCAmelCase    			=      f.readlines()
  
      # Get to the point we do the actual imports for type checking
      lowerCAmelCase    			=      0
      while not lines[line_index].startswith('if TYPE_CHECKING'				):
          line_index += 1
  
      lowerCAmelCase    			=      {}
      # Go through the end of the file
      while line_index < len(_UpperCAmelCase				):
          # If the line is an if is_backend_available, we grab all objects associated.
          lowerCAmelCase    			=      find_backend(lines[line_index]				)
          if backend is not None:
              while not lines[line_index].startswith('    else:'				):
                  line_index += 1
              line_index += 1
  
              lowerCAmelCase    			=      []
              # Until we unindent, add backend objects to the list
              while len(lines[line_index]				) <= 1 or lines[line_index].startswith(' ' * 8				):
                  lowerCAmelCase    			=      lines[line_index]
                  lowerCAmelCase    			=      _re_single_line_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    			=      objects
          else:
              line_index += 1
  
      return backend_specific_objects
  def 		SCREAMING_SNAKE_CASE__				(							_UpperCAmelCase,      _UpperCAmelCase				)					-> str:
  
  
  
      '''simple docstring'''
  
  
  
  
  
  
      if name.isupper():
          return DUMMY_CONSTANT.format(_UpperCAmelCase				)
      elif name.islower():
          return DUMMY_FUNCTION.format(_UpperCAmelCase,      _UpperCAmelCase				)
      else:
          return DUMMY_CLASS.format(_UpperCAmelCase,      _UpperCAmelCase				)
  def 		SCREAMING_SNAKE_CASE__				(							_UpperCAmelCase=None				)					-> Optional[int]:
  
  
  
      '''simple docstring'''
  
  
  
  
  
  
      if backend_specific_objects is None:
          lowerCAmelCase    			=      read_init()
      # For special correspondence backend to module name as used in the function requires_modulename
      lowerCAmelCase    			=      {}
  
      for backend, objects in backend_specific_objects.items():
          lowerCAmelCase    			=      '[' + ', '.join(f"\"{b}\"" for b in backend.split('_and_'				)				) + ']'
          lowerCAmelCase    			=      '# 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(_UpperCAmelCase,      _UpperCAmelCase				) for o in objects]				)
          lowerCAmelCase    			=      dummy_file
  
      return dummy_files
  def 		SCREAMING_SNAKE_CASE__				(							_UpperCAmelCase=False				)					-> List[str]:
  
  
  
      '''simple docstring'''
  
  
  
  
  
  
      lowerCAmelCase    			=      create_dummy_files()
      # For special correspondence backend to shortcut as used in utils/dummy_xxx_objects.py
      lowerCAmelCase    			=      {'torch': 'pt'}
  
      # Locate actual dummy modules and read their content.
      lowerCAmelCase    			=      os.path.join(_UpperCAmelCase,      'utils'				)
      lowerCAmelCase    			=      {
          backend: os.path.join(_UpperCAmelCase,      f"dummy_{short_names.get(_UpperCAmelCase,      _UpperCAmelCase				)}_objects.py"				)
          for backend in dummy_files.keys()
      }
  
      lowerCAmelCase    			=      {}
      for backend, file_path in dummy_file_paths.items():
          if os.path.isfile(_UpperCAmelCase				):
              with open(_UpperCAmelCase,      'r',      encoding='utf-8',      newline='\n'				) as f:
                  lowerCAmelCase    			=      f.read()
          else:
              lowerCAmelCase    			=      ''
  
      for backend in dummy_files.keys():
          if dummy_files[backend] != actual_dummies[backend]:
              if overwrite:
                  print(
                      f"Updating transformers.utils.dummy_{short_names.get(_UpperCAmelCase,      _UpperCAmelCase				)}_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(_UpperCAmelCase,      _UpperCAmelCase				)}_objects.py. Run `make fix-copies` "
                      'to fix this.'				)
  
  
  if __name__ == "__main__":
   __A   :     Tuple      =			argparse.ArgumentParser()
   parser.add_argument('''--fix_and_overwrite''', action='''store_true''', help='''Whether to fix inconsistencies.''')
   __A   :     Tuple      =			parser.parse_args()
  
   check_dummies(args.fix_and_overwrite)
  
  
  
  
  
  
style_context: 
  
  from typing import TYPE_CHECKING
  
  from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available
  
  
  __A   :     Optional[int]      =			{
      '''configuration_splinter''': ['''SPLINTER_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''SplinterConfig'''],
      '''tokenization_splinter''': ['''SplinterTokenizer'''],
  }
  
  try:
   if not is_tokenizers_available():
    raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
   pass
  else:
   __A   :     Optional[int]      =			['''SplinterTokenizerFast''']
  
  try:
   if not is_torch_available():
    raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
   pass
  else:
   __A   :     Union[str, Any]      =			[
       '''SPLINTER_PRETRAINED_MODEL_ARCHIVE_LIST''',
       '''SplinterForQuestionAnswering''',
       '''SplinterForPreTraining''',
       '''SplinterLayer''',
       '''SplinterModel''',
       '''SplinterPreTrainedModel''',
   ]
  
  
  if TYPE_CHECKING:
   from .configuration_splinter import SPLINTER_PRETRAINED_CONFIG_ARCHIVE_MAP, SplinterConfig
   from .tokenization_splinter import SplinterTokenizer
  
   try:
    if not is_tokenizers_available():
     raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
    pass
   else:
    from .tokenization_splinter_fast import SplinterTokenizerFast
  
   try:
    if not is_torch_available():
     raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
    pass
   else:
    from .modeling_splinter import (
        SPLINTER_PRETRAINED_MODEL_ARCHIVE_LIST,
        SplinterForPreTraining,
        SplinterForQuestionAnswering,
        SplinterLayer,
        SplinterModel,
        SplinterPreTrainedModel,
    )
  
  
  else:
   import sys
  
   __A   :     Optional[Any]      =			_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
  
  
  
  
  
  