


from __future__ import annotations

import unittest

from transformers import is_tf_available, is_torch_available
from transformers.testing_utils import DUMMY_UNKNOWN_IDENTIFIER, SMALL_MODEL_IDENTIFIER, is_pt_tf_cross_test, slow


if is_tf_available():
						from transformers import (
						    AutoConfig,
						    BertConfig,
						    GPTaConfig,
						    TaConfig,
						    TFAutoModel,
						    TFAutoModelForCausalLM,
						    TFAutoModelForMaskedLM,
						    TFAutoModelForPreTraining,
						    TFAutoModelForQuestionAnswering,
						    TFAutoModelForSeqaSeqLM,
						    TFAutoModelForSequenceClassification,
						    TFAutoModelWithLMHead,
						    TFBertForMaskedLM,
						    TFBertForPreTraining,
						    TFBertForQuestionAnswering,
						    TFBertForSequenceClassification,
						    TFBertModel,
						    TFGPTaLMHeadModel,
						    TFRobertaForMaskedLM,
						    TFTaForConditionalGeneration,
						)
						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

if is_torch_available():
						from transformers import (
						    AutoModel,
						    AutoModelForCausalLM,
						    AutoModelForMaskedLM,
						    AutoModelForPreTraining,
						    AutoModelForQuestionAnswering,
						    AutoModelForSeqaSeqLM,
						    AutoModelForSequenceClassification,
						    AutoModelWithLMHead,
						    BertForMaskedLM,
						    BertForPreTraining,
						    BertForQuestionAnswering,
						    BertForSequenceClassification,
						    BertModel,
						    GPTaLMHeadModel,
						    RobertaForMaskedLM,
						    TaForConditionalGeneration,
						)
@is_pt_tf_cross_test
class        _lowercase      (			unittest.TestCase       ):






				'''simple docstring'''



				@slow
				def 		__magic_name__(       self			:int	)		->			Union[str, Any]:
										# for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
										for model_name in ["bert-base-uncased"]:
																__SCREAMING_SNAKE_CASE						:     Dict					=		AutoConfig.from_pretrained(lowerCAmelCase__	)
																self.assertIsNotNone(lowerCAmelCase__	)
																self.assertIsInstance(lowerCAmelCase__			,			lowerCAmelCase__	)

																__SCREAMING_SNAKE_CASE						:     List[str]					=		TFAutoModel.from_pretrained(lowerCAmelCase__			,			from_pt=lowerCAmelCase__	)
																self.assertIsNotNone(lowerCAmelCase__	)
																self.assertIsInstance(lowerCAmelCase__			,			lowerCAmelCase__	)

																__SCREAMING_SNAKE_CASE						:     Dict					=		AutoModel.from_pretrained(lowerCAmelCase__			,			from_tf=lowerCAmelCase__	)
																self.assertIsNotNone(lowerCAmelCase__	)
																self.assertIsInstance(lowerCAmelCase__			,			lowerCAmelCase__	)


				@slow
				def 		__magic_name__(       self			:int	)		->			Union[str, Any]:
										# for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
										for model_name in ["bert-base-uncased"]:
																__SCREAMING_SNAKE_CASE						:     int					=		AutoConfig.from_pretrained(lowerCAmelCase__	)
																self.assertIsNotNone(lowerCAmelCase__	)
																self.assertIsInstance(lowerCAmelCase__			,			lowerCAmelCase__	)

																__SCREAMING_SNAKE_CASE						:     Any					=		TFAutoModelForPreTraining.from_pretrained(lowerCAmelCase__			,			from_pt=lowerCAmelCase__	)
																self.assertIsNotNone(lowerCAmelCase__	)
																self.assertIsInstance(lowerCAmelCase__			,			lowerCAmelCase__	)

																__SCREAMING_SNAKE_CASE						:     int					=		AutoModelForPreTraining.from_pretrained(lowerCAmelCase__			,			from_tf=lowerCAmelCase__	)
																self.assertIsNotNone(lowerCAmelCase__	)
																self.assertIsInstance(lowerCAmelCase__			,			lowerCAmelCase__	)


				@slow
				def 		__magic_name__(       self			:int	)		->			List[Any]:
										for model_name in TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																__SCREAMING_SNAKE_CASE						:     Tuple					=		AutoConfig.from_pretrained(lowerCAmelCase__	)
																self.assertIsNotNone(lowerCAmelCase__	)
																self.assertIsInstance(lowerCAmelCase__			,			lowerCAmelCase__	)

																__SCREAMING_SNAKE_CASE						:     List[str]					=		TFAutoModelForCausalLM.from_pretrained(lowerCAmelCase__			,			from_pt=lowerCAmelCase__	)
																__SCREAMING_SNAKE_CASE			,			__SCREAMING_SNAKE_CASE						:     List[str]					=		TFAutoModelForCausalLM.from_pretrained(
																    lowerCAmelCase__			,			output_loading_info=lowerCAmelCase__			,			from_pt=lowerCAmelCase__	)
																self.assertIsNotNone(lowerCAmelCase__	)
																self.assertIsInstance(lowerCAmelCase__			,			lowerCAmelCase__	)

																__SCREAMING_SNAKE_CASE						:     Dict					=		AutoModelForCausalLM.from_pretrained(lowerCAmelCase__			,			from_tf=lowerCAmelCase__	)
																__SCREAMING_SNAKE_CASE			,			__SCREAMING_SNAKE_CASE						:     List[str]					=		AutoModelForCausalLM.from_pretrained(
																    lowerCAmelCase__			,			output_loading_info=lowerCAmelCase__			,			from_tf=lowerCAmelCase__	)
																self.assertIsNotNone(lowerCAmelCase__	)
																self.assertIsInstance(lowerCAmelCase__			,			lowerCAmelCase__	)


				@slow
				def 		__magic_name__(       self			:Optional[int]	)		->			Dict:
										for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																__SCREAMING_SNAKE_CASE						:     Union[str, Any]					=		AutoConfig.from_pretrained(lowerCAmelCase__	)
																self.assertIsNotNone(lowerCAmelCase__	)
																self.assertIsInstance(lowerCAmelCase__			,			lowerCAmelCase__	)

																__SCREAMING_SNAKE_CASE						:     Any					=		TFAutoModelWithLMHead.from_pretrained(lowerCAmelCase__			,			from_pt=lowerCAmelCase__	)
																self.assertIsNotNone(lowerCAmelCase__	)
																self.assertIsInstance(lowerCAmelCase__			,			lowerCAmelCase__	)

																__SCREAMING_SNAKE_CASE						:     int					=		AutoModelWithLMHead.from_pretrained(lowerCAmelCase__			,			from_tf=lowerCAmelCase__	)
																self.assertIsNotNone(lowerCAmelCase__	)
																self.assertIsInstance(lowerCAmelCase__			,			lowerCAmelCase__	)


				@slow
				def 		__magic_name__(       self			:List[str]	)		->			Tuple:
										for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																__SCREAMING_SNAKE_CASE						:     Optional[Any]					=		AutoConfig.from_pretrained(lowerCAmelCase__	)
																self.assertIsNotNone(lowerCAmelCase__	)
																self.assertIsInstance(lowerCAmelCase__			,			lowerCAmelCase__	)

																__SCREAMING_SNAKE_CASE						:     Optional[Any]					=		TFAutoModelForMaskedLM.from_pretrained(lowerCAmelCase__			,			from_pt=lowerCAmelCase__	)
																__SCREAMING_SNAKE_CASE			,			__SCREAMING_SNAKE_CASE						:     Dict					=		TFAutoModelForMaskedLM.from_pretrained(
																    lowerCAmelCase__			,			output_loading_info=lowerCAmelCase__			,			from_pt=lowerCAmelCase__	)
																self.assertIsNotNone(lowerCAmelCase__	)
																self.assertIsInstance(lowerCAmelCase__			,			lowerCAmelCase__	)

																__SCREAMING_SNAKE_CASE						:     str					=		AutoModelForMaskedLM.from_pretrained(lowerCAmelCase__			,			from_tf=lowerCAmelCase__	)
																__SCREAMING_SNAKE_CASE			,			__SCREAMING_SNAKE_CASE						:     Union[str, Any]					=		AutoModelForMaskedLM.from_pretrained(
																    lowerCAmelCase__			,			output_loading_info=lowerCAmelCase__			,			from_tf=lowerCAmelCase__	)
																self.assertIsNotNone(lowerCAmelCase__	)
																self.assertIsInstance(lowerCAmelCase__			,			lowerCAmelCase__	)


				@slow
				def 		__magic_name__(       self			:int	)		->			List[str]:
										for model_name in TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																__SCREAMING_SNAKE_CASE						:     str					=		AutoConfig.from_pretrained(lowerCAmelCase__	)
																self.assertIsNotNone(lowerCAmelCase__	)
																self.assertIsInstance(lowerCAmelCase__			,			lowerCAmelCase__	)

																__SCREAMING_SNAKE_CASE						:     Any					=		TFAutoModelForSeqaSeqLM.from_pretrained(lowerCAmelCase__			,			from_pt=lowerCAmelCase__	)
																__SCREAMING_SNAKE_CASE			,			__SCREAMING_SNAKE_CASE						:     Optional[Any]					=		TFAutoModelForSeqaSeqLM.from_pretrained(
																    lowerCAmelCase__			,			output_loading_info=lowerCAmelCase__			,			from_pt=lowerCAmelCase__	)
																self.assertIsNotNone(lowerCAmelCase__	)
																self.assertIsInstance(lowerCAmelCase__			,			lowerCAmelCase__	)

																__SCREAMING_SNAKE_CASE						:     Union[str, Any]					=		AutoModelForSeqaSeqLM.from_pretrained(lowerCAmelCase__			,			from_tf=lowerCAmelCase__	)
																__SCREAMING_SNAKE_CASE			,			__SCREAMING_SNAKE_CASE						:     int					=		AutoModelForSeqaSeqLM.from_pretrained(
																    lowerCAmelCase__			,			output_loading_info=lowerCAmelCase__			,			from_tf=lowerCAmelCase__	)
																self.assertIsNotNone(lowerCAmelCase__	)
																self.assertIsInstance(lowerCAmelCase__			,			lowerCAmelCase__	)


				@slow
				def 		__magic_name__(       self			:Any	)		->			Union[str, Any]:
										# for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
										for model_name in ["bert-base-uncased"]:
																__SCREAMING_SNAKE_CASE						:     str					=		AutoConfig.from_pretrained(lowerCAmelCase__	)
																self.assertIsNotNone(lowerCAmelCase__	)
																self.assertIsInstance(lowerCAmelCase__			,			lowerCAmelCase__	)

																__SCREAMING_SNAKE_CASE						:     Dict					=		TFAutoModelForSequenceClassification.from_pretrained(lowerCAmelCase__			,			from_pt=lowerCAmelCase__	)
																self.assertIsNotNone(lowerCAmelCase__	)
																self.assertIsInstance(lowerCAmelCase__			,			lowerCAmelCase__	)

																__SCREAMING_SNAKE_CASE						:     str					=		AutoModelForSequenceClassification.from_pretrained(lowerCAmelCase__			,			from_tf=lowerCAmelCase__	)
																self.assertIsNotNone(lowerCAmelCase__	)
																self.assertIsInstance(lowerCAmelCase__			,			lowerCAmelCase__	)


				@slow
				def 		__magic_name__(       self			:Tuple	)		->			List[str]:
										# for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
										for model_name in ["bert-base-uncased"]:
																__SCREAMING_SNAKE_CASE						:     Dict					=		AutoConfig.from_pretrained(lowerCAmelCase__	)
																self.assertIsNotNone(lowerCAmelCase__	)
																self.assertIsInstance(lowerCAmelCase__			,			lowerCAmelCase__	)

																__SCREAMING_SNAKE_CASE						:     Tuple					=		TFAutoModelForQuestionAnswering.from_pretrained(lowerCAmelCase__			,			from_pt=lowerCAmelCase__	)
																self.assertIsNotNone(lowerCAmelCase__	)
																self.assertIsInstance(lowerCAmelCase__			,			lowerCAmelCase__	)

																__SCREAMING_SNAKE_CASE						:     List[str]					=		AutoModelForQuestionAnswering.from_pretrained(lowerCAmelCase__			,			from_tf=lowerCAmelCase__	)
																self.assertIsNotNone(lowerCAmelCase__	)
																self.assertIsInstance(lowerCAmelCase__			,			lowerCAmelCase__	)


				def 		__magic_name__(       self			:List[str]	)		->			Optional[Any]:
										__SCREAMING_SNAKE_CASE						:     Optional[Any]					=		TFAutoModelWithLMHead.from_pretrained(lowerCAmelCase__			,			from_pt=lowerCAmelCase__	)
										self.assertIsInstance(lowerCAmelCase__			,			lowerCAmelCase__	)
										self.assertEqual(model.num_parameters()			,			14_410	)
										self.assertEqual(model.num_parameters(only_trainable=lowerCAmelCase__	)			,			14_410	)

										__SCREAMING_SNAKE_CASE						:     Optional[int]					=		AutoModelWithLMHead.from_pretrained(lowerCAmelCase__			,			from_tf=lowerCAmelCase__	)
										self.assertIsInstance(lowerCAmelCase__			,			lowerCAmelCase__	)
										self.assertEqual(model.num_parameters()			,			14_410	)
										self.assertEqual(model.num_parameters(only_trainable=lowerCAmelCase__	)			,			14_410	)



				def 		__magic_name__(       self			:Any	)		->			int:
										__SCREAMING_SNAKE_CASE						:     Union[str, Any]					=		TFAutoModelWithLMHead.from_pretrained(lowerCAmelCase__			,			from_pt=lowerCAmelCase__	)
										self.assertIsInstance(lowerCAmelCase__			,			lowerCAmelCase__	)
										self.assertEqual(model.num_parameters()			,			14_410	)
										self.assertEqual(model.num_parameters(only_trainable=lowerCAmelCase__	)			,			14_410	)

										__SCREAMING_SNAKE_CASE						:     str					=		AutoModelWithLMHead.from_pretrained(lowerCAmelCase__			,			from_tf=lowerCAmelCase__	)
										self.assertIsInstance(lowerCAmelCase__			,			lowerCAmelCase__	)
										self.assertEqual(model.num_parameters()			,			14_410	)
										self.assertEqual(model.num_parameters(only_trainable=lowerCAmelCase__	)			,			14_410	)








import json
import os
import shutil
import tempfile
import unittest

import numpy as np

from transformers import BertTokenizerFast
from transformers.models.bert.tokenization_bert import VOCAB_FILES_NAMES, BertTokenizer
from transformers.testing_utils import require_tokenizers, require_vision
from transformers.utils import IMAGE_PROCESSOR_NAME, is_vision_available


if is_vision_available():
     from PIL import Image

     from transformers import VisionTextDualEncoderProcessor, ViTImageProcessor






@require_tokenizers
@require_vision
class 		lowercase_					(	unittest.TestCase   ):






      '''simple docstring'''




      def       __lowerCAmelCase					(      self      :						List[Any]  )    ->Tuple:




       """simple docstring"""


       a		  =      tempfile.mkdtemp()

       # fmt: off
       a		  =      ['''[UNK]''', '''[CLS]''', '''[SEP]''', '''[PAD]''', '''[MASK]''', '''want''', '''##want''', '''##ed''', '''wa''', '''un''', '''runn''', '''##ing''', ''',''', '''low''', '''lowest''']
       # fmt: on
       a		  =      os.path.join(self.tmpdirname ,					VOCAB_FILES_NAMES['''vocab_file''']  )
       with open(self.vocab_file ,					'''w''' ,					encoding='''utf-8'''  ) as vocab_writer:
        vocab_writer.write(''''''.join([x + '''\n''' for x in vocab_tokens]  )  )

       a		  =      {
           '''do_resize''': True,
           '''size''': {'''height''': 18, '''width''': 18},
           '''do_normalize''': True,
           '''image_mean''': [0.5, 0.5, 0.5],
           '''image_std''': [0.5, 0.5, 0.5],
       }
       a		  =      os.path.join(self.tmpdirname ,					__UpperCAmelCase  )
       with open(self.image_processor_file ,					'''w''' ,					encoding='''utf-8'''  ) as fp:
        json.dump(__UpperCAmelCase ,					__UpperCAmelCase  )







      def       __lowerCAmelCase					(      self      :						List[Any] ,					**__UpperCAmelCase      :						List[Any]  )    ->int:




       """simple docstring"""


       return BertTokenizer.from_pretrained(self.tmpdirname ,					**__UpperCAmelCase  )







      def       __lowerCAmelCase					(      self      :						Union[str, Any] ,					**__UpperCAmelCase      :						Optional[int]  )    ->Union[str, Any]:




       """simple docstring"""


       return ViTImageProcessor.from_pretrained(self.tmpdirname ,					**__UpperCAmelCase  )







      def       __lowerCAmelCase					(      self      :						Tuple  )    ->Any:




       """simple docstring"""


       shutil.rmtree(self.tmpdirname  )







      def       __lowerCAmelCase					(      self      :						str  )    ->Dict:




       """simple docstring"""


       a		  =      [np.random.randint(255 ,					size=(3, 30, 400) ,					dtype=np.uinta  )]

       a		  =      [Image.fromarray(np.moveaxis(__UpperCAmelCase ,					0 ,					-1  )  ) for x in image_inputs]

       return image_inputs







      def       __lowerCAmelCase					(      self      :						Any  )    ->Tuple:




       """simple docstring"""


       a		  =      self.get_tokenizer()
       a		  =      self.get_image_processor()

       a		  =      VisionTextDualEncoderProcessor(tokenizer=__UpperCAmelCase ,					image_processor=__UpperCAmelCase  )

       processor.save_pretrained(self.tmpdirname  )
       a		  =      VisionTextDualEncoderProcessor.from_pretrained(self.tmpdirname  )

       self.assertEqual(processor.tokenizer.get_vocab() ,					tokenizer.get_vocab()  )
       self.assertIsInstance(processor.tokenizer ,					(BertTokenizer, BertTokenizerFast)  )

       self.assertEqual(processor.image_processor.to_json_string() ,					image_processor.to_json_string()  )
       self.assertIsInstance(processor.image_processor ,					__UpperCAmelCase  )







      def       __lowerCAmelCase					(      self      :						int  )    ->Dict:




       """simple docstring"""


       a		  =      VisionTextDualEncoderProcessor(
           tokenizer=self.get_tokenizer() ,					image_processor=self.get_image_processor()  )
       processor.save_pretrained(self.tmpdirname  )

       a		  =      self.get_tokenizer(bos_token='''(BOS)''' ,					eos_token='''(EOS)'''  )
       a		  =      self.get_image_processor(do_normalize=__UpperCAmelCase ,					padding_value=1.0  )

       a		  =      VisionTextDualEncoderProcessor.from_pretrained(
           self.tmpdirname ,					bos_token='''(BOS)''' ,					eos_token='''(EOS)''' ,					do_normalize=__UpperCAmelCase ,					padding_value=1.0  )

       self.assertEqual(processor.tokenizer.get_vocab() ,					tokenizer_add_kwargs.get_vocab()  )
       self.assertIsInstance(processor.tokenizer ,					(BertTokenizer, BertTokenizerFast)  )

       self.assertEqual(processor.image_processor.to_json_string() ,					image_processor_add_kwargs.to_json_string()  )
       self.assertIsInstance(processor.image_processor ,					__UpperCAmelCase  )







      def       __lowerCAmelCase					(      self      :						Tuple  )    ->Dict:




       """simple docstring"""


       a		  =      self.get_image_processor()
       a		  =      self.get_tokenizer()

       a		  =      VisionTextDualEncoderProcessor(tokenizer=__UpperCAmelCase ,					image_processor=__UpperCAmelCase  )

       a		  =      self.prepare_image_inputs()

       a		  =      image_processor(__UpperCAmelCase ,					return_tensors='''np'''  )
       a		  =      processor(images=__UpperCAmelCase ,					return_tensors='''np'''  )

       for key in input_feat_extract.keys():
        self.assertAlmostEqual(input_feat_extract[key].sum() ,					input_processor[key].sum() ,					delta=1e-2  )







      def       __lowerCAmelCase					(      self      :						List[str]  )    ->str:




       """simple docstring"""


       a		  =      self.get_image_processor()
       a		  =      self.get_tokenizer()

       a		  =      VisionTextDualEncoderProcessor(tokenizer=__UpperCAmelCase ,					image_processor=__UpperCAmelCase  )

       a		  =      '''lower newer'''

       a		  =      processor(text=__UpperCAmelCase  )

       a		  =      tokenizer(__UpperCAmelCase  )

       for key in encoded_tok.keys():
        self.assertListEqual(encoded_tok[key] ,					encoded_processor[key]  )







      def       __lowerCAmelCase					(      self      :						List[Any]  )    ->List[str]:




       """simple docstring"""


       a		  =      self.get_image_processor()
       a		  =      self.get_tokenizer()

       a		  =      VisionTextDualEncoderProcessor(tokenizer=__UpperCAmelCase ,					image_processor=__UpperCAmelCase  )

       a		  =      '''lower newer'''
       a		  =      self.prepare_image_inputs()

       a		  =      processor(text=__UpperCAmelCase ,					images=__UpperCAmelCase  )

       self.assertListEqual(list(inputs.keys()  ) ,					['''input_ids''', '''token_type_ids''', '''attention_mask''', '''pixel_values''']  )

       # test if it raises when no input is passed
       with self.assertRaises(__UpperCAmelCase  ):
        processor()







      def       __lowerCAmelCase					(      self      :						Optional[int]  )    ->List[str]:




       """simple docstring"""


       a		  =      self.get_image_processor()
       a		  =      self.get_tokenizer()

       a		  =      VisionTextDualEncoderProcessor(tokenizer=__UpperCAmelCase ,					image_processor=__UpperCAmelCase  )

       a		  =      [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

       a		  =      processor.batch_decode(__UpperCAmelCase  )
       a		  =      tokenizer.batch_decode(__UpperCAmelCase  )

       self.assertListEqual(__UpperCAmelCase ,					__UpperCAmelCase  )







      def       __lowerCAmelCase					(      self      :						Optional[Any]  )    ->Dict:




       """simple docstring"""


       a		  =      self.get_image_processor()
       a		  =      self.get_tokenizer()

       a		  =      VisionTextDualEncoderProcessor(tokenizer=__UpperCAmelCase ,					image_processor=__UpperCAmelCase  )

       a		  =      '''lower newer'''
       a		  =      self.prepare_image_inputs()

       a		  =      processor(text=__UpperCAmelCase ,					images=__UpperCAmelCase  )

       self.assertListEqual(list(inputs.keys()  ) ,					processor.model_input_names  )


