


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									=		'src/transformers'

# Matches is_xxx_available()
_A									=		re.compile(R'is\_([a-z_]*)_available()')
# Matches from xxx import bla
_A									=		re.compile(R'\s+from\s+\S*\s+import\s+([^\(\s].*)\n')
_A									=		re.compile(R'^\s+if\s+not\s+\(?is\_[a-z_]*\_available\(\)')


_A									=		'\n{0} = None\n'

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


_A									=		'\ndef {0}(*args, **kwargs):\n    requires_backends({0}, {1})\n'

def 		_UpperCAmelCase							(     SCREAMING_SNAKE_CASE__     :   List[Any]							):
     if _re_test_backend.search(SCREAMING_SNAKE_CASE__							) is None:
          return None
     __UpperCamelCase       				=[b[0] for b in _re_backend.findall(SCREAMING_SNAKE_CASE__							)]
     backends.sort()
     return "_and_".join(SCREAMING_SNAKE_CASE__							)

def 		_UpperCAmelCase							(     ):
     with open(os.path.join(SCREAMING_SNAKE_CASE__     ,	'__init__.py'							)     ,	'r'     ,	encoding='utf-8'     ,	newline='\n'							) as f:
          __UpperCamelCase       				=f.readlines()

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

     __UpperCamelCase       				={}
     # 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       				=find_backend(lines[line_index]							)
          if backend is not None:
               while not lines[line_index].startswith('    else:'							):
                    line_index += 1
               line_index += 1

               __UpperCamelCase       				=[]
               # Until we unindent, add backend objects to the list
               while len(lines[line_index]							) <= 1 or lines[line_index].startswith(' ' * 8							):
                    __UpperCamelCase       				=lines[line_index]
                    __UpperCamelCase       				=_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(' ' * 12							):
                         objects.append(line[12:-2]							)
                    line_index += 1

               __UpperCamelCase       				=objects
          else:
               line_index += 1

     return backend_specific_objects

def 		_UpperCAmelCase							(     SCREAMING_SNAKE_CASE__     :   List[Any]     ,	SCREAMING_SNAKE_CASE__     :   List[Any]							):
     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 		_UpperCAmelCase							(     SCREAMING_SNAKE_CASE__     :   str=None							):
     if backend_specific_objects is None:
          __UpperCamelCase       				=read_init()
     # For special correspondence backend to module name as used in the function requires_modulename
     __UpperCamelCase       				={}

     for backend, objects in backend_specific_objects.items():
          __UpperCamelCase       				='[' + ', '.join(F'"{b}"' for b in backend.split('_and_'							)							) + ']'
          __UpperCamelCase       				='# 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       				=dummy_file

     return dummy_files

def 		_UpperCAmelCase							(     SCREAMING_SNAKE_CASE__     :   Union[str, Any]=False							):
     __UpperCamelCase       				=create_dummy_files()
     # For special correspondence backend to shortcut as used in utils/dummy_xxx_objects.py
     __UpperCamelCase       				={'torch': 'pt'}

     # Locate actual dummy modules and read their content.
     __UpperCamelCase       				=os.path.join(SCREAMING_SNAKE_CASE__     ,	'utils'							)
     __UpperCamelCase       				={
         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       				={}
     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       				=f.read()
          else:
               __UpperCamelCase       				=''

     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__":
   _A									=		argparse.ArgumentParser()
   parser.add_argument('--fix_and_overwrite', action='store_true', help='Whether to fix inconsistencies.')
   _A									=		parser.parse_args()

   check_dummies(args.fix_and_overwrite)









from typing import TYPE_CHECKING

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


_A									=		{
    'configuration_flaubert': ['FLAUBERT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'FlaubertConfig', 'FlaubertOnnxConfig'],
    'tokenization_flaubert': ['FlaubertTokenizer'],
}

try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   _A									=		[
       'FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST',
       'FlaubertForMultipleChoice',
       'FlaubertForQuestionAnswering',
       'FlaubertForQuestionAnsweringSimple',
       'FlaubertForSequenceClassification',
       'FlaubertForTokenClassification',
       'FlaubertModel',
       'FlaubertWithLMHeadModel',
       'FlaubertPreTrainedModel',
   ]

try:
   if not is_tf_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   _A									=		[
       'TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST',
       'TFFlaubertForMultipleChoice',
       'TFFlaubertForQuestionAnsweringSimple',
       'TFFlaubertForSequenceClassification',
       'TFFlaubertForTokenClassification',
       'TFFlaubertModel',
       'TFFlaubertPreTrainedModel',
       'TFFlaubertWithLMHeadModel',
   ]


if TYPE_CHECKING:
   from .configuration_flaubert import FLAUBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, FlaubertConfig, FlaubertOnnxConfig
   from .tokenization_flaubert import FlaubertTokenizer

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_flaubert import (
          FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
          FlaubertForMultipleChoice,
          FlaubertForQuestionAnswering,
          FlaubertForQuestionAnsweringSimple,
          FlaubertForSequenceClassification,
          FlaubertForTokenClassification,
          FlaubertModel,
          FlaubertPreTrainedModel,
          FlaubertWithLMHeadModel,
      )

   try:
      if not is_tf_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_tf_flaubert import (
          TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
          TFFlaubertForMultipleChoice,
          TFFlaubertForQuestionAnsweringSimple,
          TFFlaubertForSequenceClassification,
          TFFlaubertForTokenClassification,
          TFFlaubertModel,
          TFFlaubertPreTrainedModel,
          TFFlaubertWithLMHeadModel,
      )

else:
   import sys

   _A									=		_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)





