





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
snake_case 				=       """src/diffusers"""

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


snake_case 				=       """
{0} = None
"""

snake_case 				=       """
class {0}(metaclass=DummyObject):
    _backends = {1}

    def __init__(self, *args, **kwargs):
        requires_backends(self, {1})

    @classmethod
    def from_config(cls, *args, **kwargs):
        requires_backends(cls, {1})

    @classmethod
    def from_pretrained(cls, *args, **kwargs):
        requires_backends(cls, {1})
"""


snake_case 				=       """
def {0}(*args, **kwargs):
    requires_backends({0}, {1})
"""

def 							SCREAMING_SNAKE_CASE__       (  snake_case__  :List[Any]     )      ->						Union[str, Any]:
  _lowercase							= _re_backend.findall(snake_case__     )
  if len(snake_case__     ) == 0:
    return None

  return "_and_".join(snake_case__     )

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

  # Get to the point we do the actual imports for type checking
  _lowercase							= 0
  _lowercase							= {}
  # Go through the end of the file
  while line_index < len(snake_case__     ):
    # If the line contains is_backend_available, we grab all objects associated with the `else` block
    _lowercase							= find_backend(lines[line_index]     )
    if backend is not None:
      while not lines[line_index].startswith('else:'     ):
        line_index += 1
      line_index += 1
      _lowercase							= []
      # Until we unindent, add backend objects to the list
      while line_index < len(snake_case__     ) and len(lines[line_index]     ) > 1:
        _lowercase							= lines[line_index]
        _lowercase							= _re_single_line_import.search(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

      if len(snake_case__     ) > 0:
        _lowercase							= objects
    else:
      line_index += 1

  return backend_specific_objects

def 							SCREAMING_SNAKE_CASE__       (  snake_case__  :Optional[Any]			,							snake_case__  :Union[str, Any]     )      ->						List[Any]:
  if name.isupper():
    return DUMMY_CONSTANT.format(snake_case__     )
  elif name.islower():
    return DUMMY_FUNCTION.format(snake_case__			,							snake_case__     )
  else:
    return DUMMY_CLASS.format(snake_case__			,							snake_case__     )

def 							SCREAMING_SNAKE_CASE__       (  snake_case__  :Optional[int]=None     )      ->						str:
  if backend_specific_objects is None:
    _lowercase							= read_init()
  # For special correspondence backend to module name as used in the function requires_modulename
  _lowercase							= {}

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

  return dummy_files

def 							SCREAMING_SNAKE_CASE__       (  snake_case__  :str=False     )      ->						List[str]:
  _lowercase							= create_dummy_files()
  # For special correspondence backend to shortcut as used in utils/dummy_xxx_objects.py
  _lowercase							= {'torch': 'pt'}

  # Locate actual dummy modules and read their content.
  _lowercase							= os.path.join(snake_case__			,							'utils'     )
  _lowercase							= {
      backend: os.path.join(snake_case__			,							F"""dummy_{short_names.get(snake_case__			,							snake_case__     )}_objects.py"""     )
      for backend in dummy_files.keys()
  }

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

  for backend in dummy_files.keys():
    if dummy_files[backend] != actual_dummies[backend]:
      if overwrite:
        print(
            F"""Updating diffusers.utils.dummy_{short_names.get(snake_case__			,							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"""diffusers.utils.dummy_{short_names.get(snake_case__			,							snake_case__     )}_objects.py. Run `make fix-copies` """
            'to fix this.'     )


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

      check_dummies(args.fix_and_overwrite)






from typing import TYPE_CHECKING

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


snake_case 				=       {
    """configuration_bert""": ["""BERT_PRETRAINED_CONFIG_ARCHIVE_MAP""", """BertConfig""", """BertOnnxConfig"""],
    """tokenization_bert""": ["""BasicTokenizer""", """BertTokenizer""", """WordpieceTokenizer"""],
}

try:
      if not is_tokenizers_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      snake_case 				=       ["""BertTokenizerFast"""]

try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      snake_case 				=       [
          """BERT_PRETRAINED_MODEL_ARCHIVE_LIST""",
          """BertForMaskedLM""",
          """BertForMultipleChoice""",
          """BertForNextSentencePrediction""",
          """BertForPreTraining""",
          """BertForQuestionAnswering""",
          """BertForSequenceClassification""",
          """BertForTokenClassification""",
          """BertLayer""",
          """BertLMHeadModel""",
          """BertModel""",
          """BertPreTrainedModel""",
          """load_tf_weights_in_bert""",
      ]

try:
      if not is_tf_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      snake_case 				=       [
          """TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST""",
          """TFBertEmbeddings""",
          """TFBertForMaskedLM""",
          """TFBertForMultipleChoice""",
          """TFBertForNextSentencePrediction""",
          """TFBertForPreTraining""",
          """TFBertForQuestionAnswering""",
          """TFBertForSequenceClassification""",
          """TFBertForTokenClassification""",
          """TFBertLMHeadModel""",
          """TFBertMainLayer""",
          """TFBertModel""",
          """TFBertPreTrainedModel""",
      ]
try:
      if not is_tensorflow_text_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      snake_case 				=       ["""TFBertTokenizer"""]

try:
      if not is_flax_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      snake_case 				=       [
          """FlaxBertForCausalLM""",
          """FlaxBertForMaskedLM""",
          """FlaxBertForMultipleChoice""",
          """FlaxBertForNextSentencePrediction""",
          """FlaxBertForPreTraining""",
          """FlaxBertForQuestionAnswering""",
          """FlaxBertForSequenceClassification""",
          """FlaxBertForTokenClassification""",
          """FlaxBertModel""",
          """FlaxBertPreTrainedModel""",
      ]

if TYPE_CHECKING:
      from .configuration_bert import BERT_PRETRAINED_CONFIG_ARCHIVE_MAP, BertConfig, BertOnnxConfig
      from .tokenization_bert import BasicTokenizer, BertTokenizer, WordpieceTokenizer

      try:
            if not is_tokenizers_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .tokenization_bert_fast import BertTokenizerFast

      try:
            if not is_torch_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_bert import (
                BERT_PRETRAINED_MODEL_ARCHIVE_LIST,
                BertForMaskedLM,
                BertForMultipleChoice,
                BertForNextSentencePrediction,
                BertForPreTraining,
                BertForQuestionAnswering,
                BertForSequenceClassification,
                BertForTokenClassification,
                BertLayer,
                BertLMHeadModel,
                BertModel,
                BertPreTrainedModel,
                load_tf_weights_in_bert,
            )

      try:
            if not is_tf_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_tf_bert import (
                TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST,
                TFBertEmbeddings,
                TFBertForMaskedLM,
                TFBertForMultipleChoice,
                TFBertForNextSentencePrediction,
                TFBertForPreTraining,
                TFBertForQuestionAnswering,
                TFBertForSequenceClassification,
                TFBertForTokenClassification,
                TFBertLMHeadModel,
                TFBertMainLayer,
                TFBertModel,
                TFBertPreTrainedModel,
            )

      try:
            if not is_tensorflow_text_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .tokenization_bert_tf import TFBertTokenizer

      try:
            if not is_flax_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_flax_bert import (
                FlaxBertForCausalLM,
                FlaxBertForMaskedLM,
                FlaxBertForMultipleChoice,
                FlaxBertForNextSentencePrediction,
                FlaxBertForPreTraining,
                FlaxBertForQuestionAnswering,
                FlaxBertForSequenceClassification,
                FlaxBertForTokenClassification,
                FlaxBertModel,
                FlaxBertPreTrainedModel,
            )

else:
      import sys

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