



from __future__ import annotations

import copy
import tempfile
import unittest

from transformers import CONFIG_MAPPING, AutoConfig, BertConfig, GPTaConfig, TaConfig, TapasConfig, is_tf_available
from transformers.testing_utils import (
    DUMMY_UNKNOWN_IDENTIFIER,
    SMALL_MODEL_IDENTIFIER,
    RequestCounter,
    require_tensorflow_probability,
    require_tf,
    slow,
)

from ..bert.test_modeling_bert import BertModelTester


if is_tf_available():
     from transformers import (
         TFAutoModel,
         TFAutoModelForCausalLM,
         TFAutoModelForMaskedLM,
         TFAutoModelForPreTraining,
         TFAutoModelForQuestionAnswering,
         TFAutoModelForSeqaSeqLM,
         TFAutoModelForSequenceClassification,
         TFAutoModelForTableQuestionAnswering,
         TFAutoModelForTokenClassification,
         TFAutoModelWithLMHead,
         TFBertForMaskedLM,
         TFBertForPreTraining,
         TFBertForQuestionAnswering,
         TFBertForSequenceClassification,
         TFBertModel,
         TFFunnelBaseModel,
         TFFunnelModel,
         TFGPTaLMHeadModel,
         TFRobertaForMaskedLM,
         TFTaForConditionalGeneration,
         TFTapasForQuestionAnswering,
     )
     from transformers.models.auto.modeling_tf_auto import (
         TF_MODEL_FOR_CAUSAL_LM_MAPPING,
         TF_MODEL_FOR_MASKED_LM_MAPPING,
         TF_MODEL_FOR_PRETRAINING_MAPPING,
         TF_MODEL_FOR_QUESTION_ANSWERING_MAPPING,
         TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
         TF_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
         TF_MODEL_MAPPING,
     )
     from transformers.models.bert.modeling_tf_bert import TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST
     from transformers.models.gpta.modeling_tf_gpta import TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST
     from transformers.models.ta.modeling_tf_ta import TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST
     from transformers.models.tapas.modeling_tf_tapas import TF_TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST






class SCREAMING_SNAKE_CASE__					(		SCREAMING_SNAKE_CASE__   ):




    '''simple docstring'''






    __lowerCamelCase      :			int =				"new-model"


if is_tf_available():






     class SCREAMING_SNAKE_CASE__					(		SCREAMING_SNAKE_CASE__   ):




         '''simple docstring'''






         __lowerCamelCase      :			Tuple =				NewModelConfig






@require_tf
class SCREAMING_SNAKE_CASE__					(		unittest.TestCase   ):




    '''simple docstring'''






    @slow
    def       _lowerCAmelCase (	self		):
        __UpperCamelCase			:	List[Any]										=       """bert-base-cased"""
        __UpperCamelCase			:	Union[str, Any]										=       AutoConfig.from_pretrained(lowerCamelCase_		)
        self.assertIsNotNone(lowerCamelCase_		)
        self.assertIsInstance(lowerCamelCase_,		lowerCamelCase_		)

        __UpperCamelCase			:	Dict										=       TFAutoModel.from_pretrained(lowerCamelCase_		)
        self.assertIsNotNone(lowerCamelCase_		)
        self.assertIsInstance(lowerCamelCase_,		lowerCamelCase_		)






    @slow
    def       _lowerCAmelCase (	self		):
        __UpperCamelCase			:	Optional[int]										=       """bert-base-cased"""
        __UpperCamelCase			:	Optional[int]										=       AutoConfig.from_pretrained(lowerCamelCase_		)
        self.assertIsNotNone(lowerCamelCase_		)
        self.assertIsInstance(lowerCamelCase_,		lowerCamelCase_		)

        __UpperCamelCase			:	List[Any]										=       TFAutoModelForPreTraining.from_pretrained(lowerCamelCase_		)
        self.assertIsNotNone(lowerCamelCase_		)
        self.assertIsInstance(lowerCamelCase_,		lowerCamelCase_		)






    @slow
    def       _lowerCAmelCase (	self		):

        for model_name in TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
            __UpperCamelCase			:	Any										=       AutoConfig.from_pretrained(lowerCamelCase_		)
            self.assertIsNotNone(lowerCamelCase_		)
            self.assertIsInstance(lowerCamelCase_,		lowerCamelCase_		)

            __UpperCamelCase			:	Union[str, Any]										=       TFAutoModelForCausalLM.from_pretrained(lowerCamelCase_		)
            __UpperCamelCase					,							__UpperCamelCase			:	Optional[Any]										=       TFAutoModelForCausalLM.from_pretrained(lowerCamelCase_,		output_loading_info=lowerCamelCase_		)
            self.assertIsNotNone(lowerCamelCase_		)
            self.assertIsInstance(lowerCamelCase_,		lowerCamelCase_		)






    @slow
    def       _lowerCAmelCase (	self		):

        for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
            __UpperCamelCase			:	List[str]										=       AutoConfig.from_pretrained(lowerCamelCase_		)
            self.assertIsNotNone(lowerCamelCase_		)
            self.assertIsInstance(lowerCamelCase_,		lowerCamelCase_		)

            __UpperCamelCase			:	int										=       TFAutoModelWithLMHead.from_pretrained(lowerCamelCase_		)
            self.assertIsNotNone(lowerCamelCase_		)
            self.assertIsInstance(lowerCamelCase_,		lowerCamelCase_		)






    @slow
    def       _lowerCAmelCase (	self		):

        for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
            __UpperCamelCase			:	Any										=       AutoConfig.from_pretrained(lowerCamelCase_		)
            self.assertIsNotNone(lowerCamelCase_		)
            self.assertIsInstance(lowerCamelCase_,		lowerCamelCase_		)

            __UpperCamelCase			:	int										=       TFAutoModelForMaskedLM.from_pretrained(lowerCamelCase_		)
            __UpperCamelCase					,							__UpperCamelCase			:	Any										=       TFAutoModelForMaskedLM.from_pretrained(lowerCamelCase_,		output_loading_info=lowerCamelCase_		)
            self.assertIsNotNone(lowerCamelCase_		)
            self.assertIsInstance(lowerCamelCase_,		lowerCamelCase_		)






    @slow
    def       _lowerCAmelCase (	self		):

        for model_name in TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
            __UpperCamelCase			:	Tuple										=       AutoConfig.from_pretrained(lowerCamelCase_		)
            self.assertIsNotNone(lowerCamelCase_		)
            self.assertIsInstance(lowerCamelCase_,		lowerCamelCase_		)

            __UpperCamelCase			:	List[str]										=       TFAutoModelForSeqaSeqLM.from_pretrained(lowerCamelCase_		)
            __UpperCamelCase					,							__UpperCamelCase			:	str										=       TFAutoModelForSeqaSeqLM.from_pretrained(lowerCamelCase_,		output_loading_info=lowerCamelCase_		)
            self.assertIsNotNone(lowerCamelCase_		)
            self.assertIsInstance(lowerCamelCase_,		lowerCamelCase_		)






    @slow
    def       _lowerCAmelCase (	self		):

        for model_name in ["bert-base-uncased"]:
            __UpperCamelCase			:	str										=       AutoConfig.from_pretrained(lowerCamelCase_		)
            self.assertIsNotNone(lowerCamelCase_		)
            self.assertIsInstance(lowerCamelCase_,		lowerCamelCase_		)

            __UpperCamelCase			:	Optional[Any]										=       TFAutoModelForSequenceClassification.from_pretrained(lowerCamelCase_		)
            self.assertIsNotNone(lowerCamelCase_		)
            self.assertIsInstance(lowerCamelCase_,		lowerCamelCase_		)






    @slow
    def       _lowerCAmelCase (	self		):

        for model_name in ["bert-base-uncased"]:
            __UpperCamelCase			:	int										=       AutoConfig.from_pretrained(lowerCamelCase_		)
            self.assertIsNotNone(lowerCamelCase_		)
            self.assertIsInstance(lowerCamelCase_,		lowerCamelCase_		)

            __UpperCamelCase			:	Optional[Any]										=       TFAutoModelForQuestionAnswering.from_pretrained(lowerCamelCase_		)
            self.assertIsNotNone(lowerCamelCase_		)
            self.assertIsInstance(lowerCamelCase_,		lowerCamelCase_		)






    @slow
    @require_tensorflow_probability
    def       _lowerCAmelCase (	self		):

        for model_name in TF_TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST[5:6]:
            __UpperCamelCase			:	Tuple										=       AutoConfig.from_pretrained(lowerCamelCase_		)
            self.assertIsNotNone(lowerCamelCase_		)
            self.assertIsInstance(lowerCamelCase_,		lowerCamelCase_		)

            __UpperCamelCase			:	Tuple										=       TFAutoModelForTableQuestionAnswering.from_pretrained(lowerCamelCase_		)
            __UpperCamelCase					,							__UpperCamelCase			:	List[str]										=       TFAutoModelForTableQuestionAnswering.from_pretrained(
                lowerCamelCase_,		output_loading_info=lowerCamelCase_		)
            self.assertIsNotNone(lowerCamelCase_		)
            self.assertIsInstance(lowerCamelCase_,		lowerCamelCase_		)






    def       _lowerCAmelCase (	self		):
        __UpperCamelCase			:	int										=       TFAutoModelWithLMHead.from_pretrained(lowerCamelCase_		)
        self.assertIsInstance(lowerCamelCase_,		lowerCamelCase_		)
        self.assertEqual(model.num_parameters(),		1_4410		)
        self.assertEqual(model.num_parameters(only_trainable=lowerCamelCase_		),		1_4410		)






    def       _lowerCAmelCase (	self		):
        __UpperCamelCase			:	Dict										=       TFAutoModelWithLMHead.from_pretrained(lowerCamelCase_		)
        self.assertIsInstance(lowerCamelCase_,		lowerCamelCase_		)
        self.assertEqual(model.num_parameters(),		1_4410		)
        self.assertEqual(model.num_parameters(only_trainable=lowerCamelCase_		),		1_4410		)






    def       _lowerCAmelCase (	self		):
        __UpperCamelCase			:	List[Any]										=       TFAutoModel.from_pretrained("""sgugger/funnel-random-tiny"""		)
        self.assertIsInstance(lowerCamelCase_,		lowerCamelCase_		)

        __UpperCamelCase			:	Any										=       copy.deepcopy(model.config		)
        __UpperCamelCase			:	Optional[Any]										=       ["""FunnelBaseModel"""]
        __UpperCamelCase			:	str										=       TFAutoModel.from_config(lowerCamelCase_		)
        self.assertIsInstance(lowerCamelCase_,		lowerCamelCase_		)

        with tempfile.TemporaryDirectory() as tmp_dir:
            model.save_pretrained(lowerCamelCase_		)
            __UpperCamelCase			:	Tuple										=       TFAutoModel.from_pretrained(lowerCamelCase_		)
            self.assertIsInstance(lowerCamelCase_,		lowerCamelCase_		)






    def       _lowerCAmelCase (	self		):

        try:
            AutoConfig.register("""new-model""",		lowerCamelCase_		)

            __UpperCamelCase			:	Dict										=       [
                TFAutoModel,
                TFAutoModelForCausalLM,
                TFAutoModelForMaskedLM,
                TFAutoModelForPreTraining,
                TFAutoModelForQuestionAnswering,
                TFAutoModelForSequenceClassification,
                TFAutoModelForTokenClassification,
            ]

            for auto_class in auto_classes:
                with self.subTest(auto_class.__name__		):
                    # Wrong config class will raise an error
                    with self.assertRaises(lowerCamelCase_		):
                        auto_class.register(lowerCamelCase_,		lowerCamelCase_		)
                    auto_class.register(lowerCamelCase_,		lowerCamelCase_		)
                    # Trying to register something existing in the Transformers library will raise an error
                    with self.assertRaises(lowerCamelCase_		):
                        auto_class.register(lowerCamelCase_,		lowerCamelCase_		)

                    # Now that the config is registered, it can be used as any other config with the auto-API
                    __UpperCamelCase			:	int										=       BertModelTester(self		).get_config()
                    __UpperCamelCase			:	Tuple										=       NewModelConfig(**tiny_config.to_dict()		)
                    __UpperCamelCase			:	List[str]										=       auto_class.from_config(lowerCamelCase_		)
                    self.assertIsInstance(lowerCamelCase_,		lowerCamelCase_		)

                    with tempfile.TemporaryDirectory() as tmp_dir:
                        model.save_pretrained(lowerCamelCase_		)
                        __UpperCamelCase			:	Optional[Any]										=       auto_class.from_pretrained(lowerCamelCase_		)
                        self.assertIsInstance(lowerCamelCase_,		lowerCamelCase_		)

        finally:
            if "new-model" in CONFIG_MAPPING._extra_content:
                del CONFIG_MAPPING._extra_content["new-model"]
            for mapping in (
                TF_MODEL_MAPPING,
                TF_MODEL_FOR_PRETRAINING_MAPPING,
                TF_MODEL_FOR_QUESTION_ANSWERING_MAPPING,
                TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
                TF_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
                TF_MODEL_FOR_CAUSAL_LM_MAPPING,
                TF_MODEL_FOR_MASKED_LM_MAPPING,
            ):
                if NewModelConfig in mapping._extra_content:
                    del mapping._extra_content[NewModelConfig]






    def       _lowerCAmelCase (	self		):

        with self.assertRaisesRegex(
            lowerCamelCase_,		"""bert-base is not a local folder and is not a valid model identifier"""		):
            __UpperCamelCase			:	Tuple										=       TFAutoModel.from_pretrained("""bert-base"""		)






    def       _lowerCAmelCase (	self		):

        with self.assertRaisesRegex(
            lowerCamelCase_,		R"""aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)"""		):
            __UpperCamelCase			:	Dict										=       TFAutoModel.from_pretrained(lowerCamelCase_,		revision="""aaaaaa"""		)






    def       _lowerCAmelCase (	self		):

        with self.assertRaisesRegex(
            lowerCamelCase_,		"""hf-internal-testing/config-no-model does not appear to have a file named pytorch_model.bin""",		):
            __UpperCamelCase			:	Any										=       TFAutoModel.from_pretrained("""hf-internal-testing/config-no-model"""		)






    def       _lowerCAmelCase (	self		):

        with self.assertRaisesRegex(lowerCamelCase_,		"""Use `from_pt=True` to load this model"""		):
            __UpperCamelCase			:	Tuple										=       TFAutoModel.from_pretrained("""hf-internal-testing/tiny-bert-pt-only"""		)






    def       _lowerCAmelCase (	self		):
        __UpperCamelCase			:	Dict										=       TFAutoModel.from_pretrained("""hf-internal-testing/tiny-random-bert"""		)
        with RequestCounter() as counter:
            __UpperCamelCase			:	Union[str, Any]										=       TFAutoModel.from_pretrained("""hf-internal-testing/tiny-random-bert"""		)
            self.assertEqual(counter.get_request_count,		0		)
            self.assertEqual(counter.head_request_count,		1		)
            self.assertEqual(counter.other_request_count,		0		)

        # With a sharded checkpoint
        __UpperCamelCase			:	Dict										=       TFAutoModel.from_pretrained("""ArthurZ/tiny-random-bert-sharded"""		)
        with RequestCounter() as counter:
            __UpperCamelCase			:	List[str]										=       TFAutoModel.from_pretrained("""ArthurZ/tiny-random-bert-sharded"""		)
            self.assertEqual(counter.get_request_count,		0		)
            self.assertEqual(counter.head_request_count,		1		)
            self.assertEqual(counter.other_request_count,		0		)







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
SCREAMING_SNAKE_CASE_:Any					=						"""src/diffusers"""

# Matches is_xxx_available()
SCREAMING_SNAKE_CASE_:Optional[Any]					=						re.compile(R"""is\_([a-z_]*)_available\(\)""")
# Matches from xxx import bla
SCREAMING_SNAKE_CASE_:Union[str, Any]					=						re.compile(R"""\s+from\s+\S*\s+import\s+([^\(\s].*)\n""")


SCREAMING_SNAKE_CASE_:List[Any]					=						"""
{0} = None
"""

SCREAMING_SNAKE_CASE_:Optional[Any]					=						"""
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})
"""


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




def      __UpperCamelCase     (  _lowerCAmelCase		)	->  Tuple:



    """simple docstring"""






    A			:	Union[str, Any]										=       _re_backend.findall(_lowerCAmelCase		)
    if len(_lowerCAmelCase		) == 0:
        return None

    return "_and_".join(_lowerCAmelCase		)




def      __UpperCamelCase     (  )	->  str:



    """simple docstring"""






    with open(os.path.join(_lowerCAmelCase				,					"""__init__.py"""		)				,					"""r"""				,					encoding="""utf-8"""				,					newline="""\n"""		) as f:
        A			:	Dict										=       f.readlines()

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

    return backend_specific_objects




def      __UpperCamelCase     (  _lowerCAmelCase				,					_lowerCAmelCase		)	->  str:



    """simple docstring"""






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




def      __UpperCamelCase     (  _lowerCAmelCase=None		)	->  Tuple:



    """simple docstring"""






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

    for backend, objects in backend_specific_objects.items():
        A			:	str										=       """[""" + """, """.join(f'''"{b}"''' for b in backend.split("""_and_"""		)		) + """]"""
        A			:	Any										=       """# 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(_lowerCAmelCase				,					_lowerCAmelCase		) for o in objects]		)
        A			:	Optional[Any]										=       dummy_file

    return dummy_files




def      __UpperCamelCase     (  _lowerCAmelCase=False		)	->  str:



    """simple docstring"""






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

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

    A			:	List[Any]										=       {}
    for backend, file_path in dummy_file_paths.items():
        if os.path.isfile(_lowerCAmelCase		):
            with open(_lowerCAmelCase				,					"""r"""				,					encoding="""utf-8"""				,					newline="""\n"""		) as f:
                A			:	Dict										=       f.read()
        else:
            A			:	str										=       """"""

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


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

     check_dummies(args.fix_and_overwrite)


