





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 				__lowerCAmelCase       (    UpperCamelCase__):
      _lowercase				:					str						=			"""new-model"""


if is_tf_available():







     class 				__lowerCAmelCase       (    UpperCamelCase__):
           _lowercase				:					Optional[int]						=			NewModelConfig







@require_tf
class 				__lowerCAmelCase       (    unittest.TestCase):







      @slow
      def    _lowercase  (    self							)   ->						List[Any]:



        '''simple docstring'''




        a__	:					str										="bert-base-cased"
        a__	:					Any										=AutoConfig.from_pretrained(lowerCAmelCase__							)
        self.assertIsNotNone(lowerCAmelCase__							)
        self.assertIsInstance(lowerCAmelCase__		,      lowerCAmelCase__							)

        a__	:					Optional[Any]										=TFAutoModel.from_pretrained(lowerCAmelCase__							)
        self.assertIsNotNone(lowerCAmelCase__							)
        self.assertIsInstance(lowerCAmelCase__		,      lowerCAmelCase__							)







      @slow
      def    _lowercase  (    self							)   ->						int:



        '''simple docstring'''




        a__	:					List[Any]										="bert-base-cased"
        a__	:					Dict										=AutoConfig.from_pretrained(lowerCAmelCase__							)
        self.assertIsNotNone(lowerCAmelCase__							)
        self.assertIsInstance(lowerCAmelCase__		,      lowerCAmelCase__							)

        a__	:					Tuple										=TFAutoModelForPreTraining.from_pretrained(lowerCAmelCase__							)
        self.assertIsNotNone(lowerCAmelCase__							)
        self.assertIsInstance(lowerCAmelCase__		,      lowerCAmelCase__							)







      @slow
      def    _lowercase  (    self							)   ->						Dict:



        '''simple docstring'''




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

          a__	:					Optional[int]										=TFAutoModelForCausalLM.from_pretrained(lowerCAmelCase__							)
          a__					,							a__	:					Union[str, Any]										=TFAutoModelForCausalLM.from_pretrained(lowerCAmelCase__		,      output_loading_info=lowerCAmelCase__							)
          self.assertIsNotNone(lowerCAmelCase__							)
          self.assertIsInstance(lowerCAmelCase__		,      lowerCAmelCase__							)







      @slow
      def    _lowercase  (    self							)   ->						Dict:



        '''simple docstring'''




        for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
          a__	:					str										=AutoConfig.from_pretrained(lowerCAmelCase__							)
          self.assertIsNotNone(lowerCAmelCase__							)
          self.assertIsInstance(lowerCAmelCase__		,      lowerCAmelCase__							)

          a__	:					List[str]										=TFAutoModelWithLMHead.from_pretrained(lowerCAmelCase__							)
          self.assertIsNotNone(lowerCAmelCase__							)
          self.assertIsInstance(lowerCAmelCase__		,      lowerCAmelCase__							)







      @slow
      def    _lowercase  (    self							)   ->						Any:



        '''simple docstring'''




        for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
          a__	:					Optional[int]										=AutoConfig.from_pretrained(lowerCAmelCase__							)
          self.assertIsNotNone(lowerCAmelCase__							)
          self.assertIsInstance(lowerCAmelCase__		,      lowerCAmelCase__							)

          a__	:					Optional[int]										=TFAutoModelForMaskedLM.from_pretrained(lowerCAmelCase__							)
          a__					,							a__	:					Dict										=TFAutoModelForMaskedLM.from_pretrained(lowerCAmelCase__		,      output_loading_info=lowerCAmelCase__							)
          self.assertIsNotNone(lowerCAmelCase__							)
          self.assertIsInstance(lowerCAmelCase__		,      lowerCAmelCase__							)







      @slow
      def    _lowercase  (    self							)   ->						Dict:



        '''simple docstring'''




        for model_name in TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
          a__	:					int										=AutoConfig.from_pretrained(lowerCAmelCase__							)
          self.assertIsNotNone(lowerCAmelCase__							)
          self.assertIsInstance(lowerCAmelCase__		,      lowerCAmelCase__							)

          a__	:					Any										=TFAutoModelForSeqaSeqLM.from_pretrained(lowerCAmelCase__							)
          a__					,							a__	:					List[Any]										=TFAutoModelForSeqaSeqLM.from_pretrained(lowerCAmelCase__		,      output_loading_info=lowerCAmelCase__							)
          self.assertIsNotNone(lowerCAmelCase__							)
          self.assertIsInstance(lowerCAmelCase__		,      lowerCAmelCase__							)







      @slow
      def    _lowercase  (    self							)   ->						Optional[Any]:



        '''simple docstring'''




        for model_name in ["bert-base-uncased"]:
          a__	:					Any										=AutoConfig.from_pretrained(lowerCAmelCase__							)
          self.assertIsNotNone(lowerCAmelCase__							)
          self.assertIsInstance(lowerCAmelCase__		,      lowerCAmelCase__							)

          a__	:					List[Any]										=TFAutoModelForSequenceClassification.from_pretrained(lowerCAmelCase__							)
          self.assertIsNotNone(lowerCAmelCase__							)
          self.assertIsInstance(lowerCAmelCase__		,      lowerCAmelCase__							)







      @slow
      def    _lowercase  (    self							)   ->						Optional[int]:



        '''simple docstring'''




        for model_name in ["bert-base-uncased"]:
          a__	:					Any										=AutoConfig.from_pretrained(lowerCAmelCase__							)
          self.assertIsNotNone(lowerCAmelCase__							)
          self.assertIsInstance(lowerCAmelCase__		,      lowerCAmelCase__							)

          a__	:					Dict										=TFAutoModelForQuestionAnswering.from_pretrained(lowerCAmelCase__							)
          self.assertIsNotNone(lowerCAmelCase__							)
          self.assertIsInstance(lowerCAmelCase__		,      lowerCAmelCase__							)







      @slow
      @require_tensorflow_probability
      def    _lowercase  (    self							)   ->						Union[str, Any]:



        '''simple docstring'''




        for model_name in TF_TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST[5:6]:
          a__	:					Any										=AutoConfig.from_pretrained(lowerCAmelCase__							)
          self.assertIsNotNone(lowerCAmelCase__							)
          self.assertIsInstance(lowerCAmelCase__		,      lowerCAmelCase__							)

          a__	:					Union[str, Any]										=TFAutoModelForTableQuestionAnswering.from_pretrained(lowerCAmelCase__							)
          a__					,							a__	:					List[str]										=TFAutoModelForTableQuestionAnswering.from_pretrained(
              lowerCAmelCase__		,      output_loading_info=lowerCAmelCase__							)
          self.assertIsNotNone(lowerCAmelCase__							)
          self.assertIsInstance(lowerCAmelCase__		,      lowerCAmelCase__							)







      def    _lowercase  (    self							)   ->						Optional[Any]:



        '''simple docstring'''




        a__	:					Optional[int]										=TFAutoModelWithLMHead.from_pretrained(lowerCAmelCase__							)
        self.assertIsInstance(lowerCAmelCase__		,      lowerCAmelCase__							)
        self.assertEqual(model.num_parameters()		,      1_4_4_1_0							)
        self.assertEqual(model.num_parameters(only_trainable=lowerCAmelCase__							)		,      1_4_4_1_0							)







      def    _lowercase  (    self							)   ->						List[Any]:



        '''simple docstring'''




        a__	:					int										=TFAutoModelWithLMHead.from_pretrained(lowerCAmelCase__							)
        self.assertIsInstance(lowerCAmelCase__		,      lowerCAmelCase__							)
        self.assertEqual(model.num_parameters()		,      1_4_4_1_0							)
        self.assertEqual(model.num_parameters(only_trainable=lowerCAmelCase__							)		,      1_4_4_1_0							)







      def    _lowercase  (    self							)   ->						Optional[Any]:



        '''simple docstring'''




        a__	:					str										=TFAutoModel.from_pretrained("sgugger/funnel-random-tiny"							)
        self.assertIsInstance(lowerCAmelCase__		,      lowerCAmelCase__							)

        a__	:					Union[str, Any]										=copy.deepcopy(model.config							)
        a__	:					Union[str, Any]										=["FunnelBaseModel"]
        a__	:					Dict										=TFAutoModel.from_config(lowerCAmelCase__							)
        self.assertIsInstance(lowerCAmelCase__		,      lowerCAmelCase__							)

        with tempfile.TemporaryDirectory() as tmp_dir:
          model.save_pretrained(lowerCAmelCase__							)
          a__	:					List[str]										=TFAutoModel.from_pretrained(lowerCAmelCase__							)
          self.assertIsInstance(lowerCAmelCase__		,      lowerCAmelCase__							)







      def    _lowercase  (    self							)   ->						int:



        '''simple docstring'''




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

          a__	:					Tuple										=[
              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
              a__	:					List[str]										=BertModelTester(self							).get_config()
              a__	:					Dict										=NewModelConfig(**tiny_config.to_dict()							)
              a__	:					Optional[int]										=auto_class.from_config(lowerCAmelCase__							)
              self.assertIsInstance(lowerCAmelCase__		,      lowerCAmelCase__							)

              with tempfile.TemporaryDirectory() as tmp_dir:
                model.save_pretrained(lowerCAmelCase__							)
                a__	:					int										=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    _lowercase  (    self							)   ->						List[Any]:



        '''simple docstring'''




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







      def    _lowercase  (    self							)   ->						Any:



        '''simple docstring'''




        with self.assertRaisesRegex(
            lowerCAmelCase__		,      r"aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)"							):
          a__	:					int										=TFAutoModel.from_pretrained(lowerCAmelCase__		,      revision="aaaaaa"							)







      def    _lowercase  (    self							)   ->						Tuple:



        '''simple docstring'''




        with self.assertRaisesRegex(
            lowerCAmelCase__		,      "hf-internal-testing/config-no-model does not appear to have a file named pytorch_model.bin"		,      ):
          a__	:					Optional[int]										=TFAutoModel.from_pretrained("hf-internal-testing/config-no-model"							)







      def    _lowercase  (    self							)   ->						Tuple:



        '''simple docstring'''




        with self.assertRaisesRegex(lowerCAmelCase__		,      "Use `from_pt=True` to load this model"							):
          a__	:					Optional[Any]										=TFAutoModel.from_pretrained("hf-internal-testing/tiny-bert-pt-only"							)







      def    _lowercase  (    self							)   ->						Dict:



        '''simple docstring'''




        a__	:					Any										=TFAutoModel.from_pretrained("hf-internal-testing/tiny-random-bert"							)
        with RequestCounter() as counter:
          a__	:					List[str]										=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
        a__	:					Any										=TFAutoModel.from_pretrained("ArthurZ/tiny-random-bert-sharded"							)
        with RequestCounter() as counter:
          a__	:					Dict										=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 unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    DPMSolverMultistepScheduler,
    TextToVideoSDPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import is_xformers_available, load_numpy, skip_mps, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()
@skip_mps
class       _UpperCAmelCase					(       A__		,unittest.TestCase	):

				"""simple docstring"""




				lowercase__											=       TextToVideoSDPipeline
				lowercase__											=       TEXT_TO_IMAGE_PARAMS
				lowercase__											=       TEXT_TO_IMAGE_BATCH_PARAMS
				# No `output_type`.
				lowercase__											=       frozenset(
				    [
				        """num_inference_steps""",
				        """generator""",
				        """latents""",
				        """return_dict""",
				        """callback""",
				        """callback_steps""",
				    ]	)




				def 				lowercase__   (     self						:    str  ):

								'''simple docstring'''
								torch.manual_seed(0  )
								lowercase__    =			UNetaDConditionModel(
								    block_out_channels=(32, 64, 64, 64),  layers_per_block=2,  sample_size=32,  in_channels=4,  out_channels=4,  down_block_types=('''CrossAttnDownBlock3D''', '''CrossAttnDownBlock3D''', '''CrossAttnDownBlock3D''', '''DownBlock3D'''),  up_block_types=('''UpBlock3D''', '''CrossAttnUpBlock3D''', '''CrossAttnUpBlock3D''', '''CrossAttnUpBlock3D'''),  cross_attention_dim=32,  attention_head_dim=4,  )
								lowercase__    =			DDIMScheduler(
								    beta_start=0.00085,  beta_end=0.012,  beta_schedule='''scaled_linear''',  clip_sample=lowerCamelCase,  set_alpha_to_one=lowerCamelCase,  )
								torch.manual_seed(0  )
								lowercase__    =			AutoencoderKL(
								    block_out_channels=[32, 64],  in_channels=3,  out_channels=3,  down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D'''],  up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D'''],  latent_channels=4,  sample_size=128,  )
								torch.manual_seed(0  )
								lowercase__    =			CLIPTextConfig(
								    bos_token_id=0,  eos_token_id=2,  hidden_size=32,  intermediate_size=37,  layer_norm_eps=1E-05,  num_attention_heads=4,  num_hidden_layers=5,  pad_token_id=1,  vocab_size=1_000,  hidden_act='''gelu''',  projection_dim=512,  )
								lowercase__    =			CLIPTextModel(lowerCamelCase  )
								lowercase__    =			CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''  )

								lowercase__    =			{
								    '''unet''': unet,
								    '''scheduler''': scheduler,
								    '''vae''': vae,
								    '''text_encoder''': text_encoder,
								    '''tokenizer''': tokenizer,
								}
								return components




				def 				lowercase__   (     self						:    int,  lowerCamelCase						:    Union[str, Any],  lowerCamelCase						:    int=0  ):

								'''simple docstring'''
								if str(lowerCamelCase  ).startswith('''mps'''  ):
												lowercase__    =			torch.manual_seed(lowerCamelCase  )
								else:
												lowercase__    =			torch.Generator(device=lowerCamelCase  ).manual_seed(lowerCamelCase  )
								lowercase__    =			{
								    '''prompt''': '''A painting of a squirrel eating a burger''',
								    '''generator''': generator,
								    '''num_inference_steps''': 2,
								    '''guidance_scale''': 6.0,
								    '''output_type''': '''pt''',
								}
								return inputs




				def 				lowercase__   (     self						:    Union[str, Any]  ):

								'''simple docstring'''
								lowercase__    =			'''cpu'''  # ensure determinism for the device-dependent torch.Generator
								lowercase__    =			self.get_dummy_components()
								lowercase__    =			TextToVideoSDPipeline(**lowerCamelCase  )
								lowercase__    =			sd_pipe.to(lowerCamelCase  )
								sd_pipe.set_progress_bar_config(disable=lowerCamelCase  )

								lowercase__    =			self.get_dummy_inputs(lowerCamelCase  )
								lowercase__    =			'''np'''
								lowercase__    =			sd_pipe(**lowerCamelCase  ).frames
								lowercase__    =			frames[0][-3:, -3:, -1]

								assert frames[0].shape == (64, 64, 3)
								lowercase__    =			np.array([158.0, 160.0, 153.0, 125.0, 100.0, 121.0, 111.0, 93.0, 113.0]  )

								assert np.abs(image_slice.flatten() - expected_slice  ).max() < 1E-2




				def 				lowercase__   (     self						:    str  ):

								'''simple docstring'''
								self._test_attention_slicing_forward_pass(test_mean_pixel_difference=lowerCamelCase,  expected_max_diff=3E-3  )




				@unittest.skipIf(
				    torch_device != '''cuda''' or not is_xformers_available(),  reason='''XFormers attention is only available with CUDA and `xformers` installed''',  )
				def 				lowercase__   (     self						:    Optional[int]  ):

								'''simple docstring'''
								self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=lowerCamelCase,  expected_max_diff=1E-2  )




				@unittest.skip(reason='''Batching needs to be properly figured out first for this pipeline.'''  )
				def 				lowercase__   (     self						:    Optional[int]  ):

								'''simple docstring'''
								pass




				@unittest.skip(reason='''Batching needs to be properly figured out first for this pipeline.'''  )
				def 				lowercase__   (     self						:    Optional[Any]  ):

								'''simple docstring'''
								pass




				@unittest.skip(reason='''`num_images_per_prompt` argument is not supported for this pipeline.'''  )
				def 				lowercase__   (     self						:    int  ):

								'''simple docstring'''
								pass




				def 				lowercase__   (     self						:    List[Any]  ):

								'''simple docstring'''
								return super().test_progress_bar()



@slow
@skip_mps
class       _UpperCAmelCase					(       unittest.TestCase	):

				"""simple docstring"""




				def 				lowercase__   (     self						:    int  ):

								'''simple docstring'''
								lowercase__    =			load_numpy(
								    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text_to_video/video.npy'''  )

								lowercase__    =			TextToVideoSDPipeline.from_pretrained('''damo-vilab/text-to-video-ms-1.7b'''  )
								lowercase__    =			DPMSolverMultistepScheduler.from_config(pipe.scheduler.config  )
								lowercase__    =			pipe.to('''cuda'''  )

								lowercase__    =			'''Spiderman is surfing'''
								lowercase__    =			torch.Generator(device='''cpu'''  ).manual_seed(0  )

								lowercase__    =			pipe(lowerCamelCase,  generator=lowerCamelCase,  num_inference_steps=25,  output_type='''pt'''  ).frames
								lowercase__    =			video_frames.cpu().numpy()

								assert np.abs(expected_video - video  ).mean() < 5E-2




				def 				lowercase__   (     self						:    int  ):

								'''simple docstring'''
								lowercase__    =			load_numpy(
								    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text_to_video/video_2step.npy'''  )

								lowercase__    =			TextToVideoSDPipeline.from_pretrained('''damo-vilab/text-to-video-ms-1.7b'''  )
								lowercase__    =			pipe.to('''cuda'''  )

								lowercase__    =			'''Spiderman is surfing'''
								lowercase__    =			torch.Generator(device='''cpu'''  ).manual_seed(0  )

								lowercase__    =			pipe(lowerCamelCase,  generator=lowerCamelCase,  num_inference_steps=2,  output_type='''pt'''  ).frames
								lowercase__    =			video_frames.cpu().numpy()

								assert np.abs(expected_video - video  ).mean() < 5E-2




