
import unittest

from transformers import AutoTokenizer, FalconConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
					import torch

					from transformers import (
					    FalconForCausalLM,
					    FalconForQuestionAnswering,
					    FalconForSequenceClassification,
					    FalconForTokenClassification,
					    FalconModel,
					)


class 				lowercase					:



		def __init__( self				,      A_				,      A_=3				,      A_=7				,      A_=True				,      A_=True				,      A_=False				,      A_=True				,      A_=99				,      A_=32				,      A_=5				,      A_=4				,      A_=37				,      A_="gelu"				,      A_=0.1				,      A_=0.1				,      A_=512				,      A_=16				,      A_=2				,      A_=0.02				,      A_=3				,      A_=4				,      A_=None				,      )  ->					Dict:
				"""simple docstring"""
				UpperCamelCase		=     parent
				UpperCamelCase		=     batch_size
				UpperCamelCase		=     seq_length
				UpperCamelCase		=     is_training
				UpperCamelCase		=     use_input_mask
				UpperCamelCase		=     use_token_type_ids
				UpperCamelCase		=     use_labels
				UpperCamelCase		=     vocab_size
				UpperCamelCase		=     hidden_size
				UpperCamelCase		=     num_hidden_layers
				UpperCamelCase		=     num_attention_heads
				UpperCamelCase		=     intermediate_size
				UpperCamelCase		=     hidden_act
				UpperCamelCase		=     hidden_dropout_prob
				UpperCamelCase		=     attention_probs_dropout_prob
				UpperCamelCase		=     max_position_embeddings
				UpperCamelCase		=     type_vocab_size
				UpperCamelCase		=     type_sequence_label_size
				UpperCamelCase		=     initializer_range
				UpperCamelCase		=     num_labels
				UpperCamelCase		=     num_choices
				UpperCamelCase		=     scope



		def __UpperCamelCase ( self       )  ->					Tuple:
				"""simple docstring"""
				UpperCamelCase		=     ids_tensor([self.batch_size, self.seq_length]				,      self.vocab_size       )

				UpperCamelCase		=     None
				if self.use_input_mask:
						UpperCamelCase		=     random_attention_mask([self.batch_size, self.seq_length]       )

				UpperCamelCase		=     None

				UpperCamelCase		=     None
				UpperCamelCase		=     None
				UpperCamelCase		=     None
				if self.use_labels:
						UpperCamelCase		=     ids_tensor([self.batch_size]				,      self.type_sequence_label_size       )
						UpperCamelCase		=     ids_tensor([self.batch_size, self.seq_length]				,      self.num_labels       )
						UpperCamelCase		=     ids_tensor([self.batch_size]				,      self.num_choices       )

				UpperCamelCase		=     self.get_config()

				return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels



		def __UpperCamelCase ( self       )  ->					Any:
				"""simple docstring"""
				return FalconConfig(
				    vocab_size=self.vocab_size				,      hidden_size=self.hidden_size				,      num_hidden_layers=self.num_hidden_layers				,      num_attention_heads=self.num_attention_heads				,      intermediate_size=self.intermediate_size				,      hidden_act=self.hidden_act				,      hidden_dropout_prob=self.hidden_dropout_prob				,      attention_probs_dropout_prob=self.attention_probs_dropout_prob				,      max_position_embeddings=self.max_position_embeddings				,      type_vocab_size=self.type_vocab_size				,      is_decoder=_a				,      initializer_range=self.initializer_range				,      pad_token_id=1				,      new_decoder_architecture=_a				,      )



		def __UpperCamelCase ( self				,      A_				,      A_				,      A_				,      A_				,      A_				,      A_				,      A_       )  ->					Dict:
				"""simple docstring"""
				UpperCamelCase		=     FalconModel(config=_a       )
				model.to(_a       )
				model.eval()
				UpperCamelCase		=     model(_a				,      attention_mask=_a       )
				UpperCamelCase		=     model(_a       )
				self.parent.assertEqual(result.last_hidden_state.shape				,      (self.batch_size, self.seq_length, self.hidden_size)       )



		def __UpperCamelCase ( self				,      A_				,      A_				,      A_				,      A_				,      A_				,      A_				,      A_				,      A_				,      A_				,      )  ->					int:
				"""simple docstring"""
				UpperCamelCase		=     True
				UpperCamelCase		=     FalconModel(_a       )
				model.to(_a       )
				model.eval()
				UpperCamelCase		=     model(
				    _a				,      attention_mask=_a				,      encoder_hidden_states=_a				,      encoder_attention_mask=_a				,      )
				UpperCamelCase		=     model(
				    _a				,      attention_mask=_a				,      encoder_hidden_states=_a				,      )
				UpperCamelCase		=     model(_a				,      attention_mask=_a       )
				self.parent.assertEqual(result.last_hidden_state.shape				,      (self.batch_size, self.seq_length, self.hidden_size)       )



		def __UpperCamelCase ( self				,      A_				,      A_				,      A_				,      A_				,      A_				,      A_				,      A_				,      A_				,      A_				,      )  ->					List[Any]:
				"""simple docstring"""
				UpperCamelCase		=     FalconForCausalLM(config=_a       )
				model.to(_a       )
				model.eval()
				UpperCamelCase		=     model(_a				,      attention_mask=_a				,      labels=_a       )
				self.parent.assertEqual(result.logits.shape				,      (self.batch_size, self.seq_length, self.vocab_size)       )



		def __UpperCamelCase ( self				,      A_				,      A_				,      A_				,      A_				,      A_				,      A_				,      A_				,      A_				,      A_				,      )  ->					int:
				"""simple docstring"""
				UpperCamelCase		=     True
				UpperCamelCase		=     True
				UpperCamelCase		=     FalconForCausalLM(config=_a       )
				model.to(_a       )
				model.eval()

				# first forward pass
				UpperCamelCase		=     model(
				    _a				,      attention_mask=_a				,      encoder_hidden_states=_a				,      encoder_attention_mask=_a				,      use_cache=_a				,      )
				UpperCamelCase		=     outputs.past_key_values

				# create hypothetical multiple next token and extent to next_input_ids
				UpperCamelCase		=     ids_tensor((self.batch_size, 3)				,      config.vocab_size       )
				UpperCamelCase		=     ids_tensor((self.batch_size, 3)				,      vocab_size=2       )

				# append to next input_ids and
				UpperCamelCase		=     torch.cat([input_ids, next_tokens]				,      dim=-1       )
				UpperCamelCase		=     torch.cat([input_mask, next_mask]				,      dim=-1       )

				UpperCamelCase		=     model(
				    _a				,      attention_mask=_a				,      encoder_hidden_states=_a				,      encoder_attention_mask=_a				,      output_hidden_states=_a				,      )['hidden_states'][0]
				UpperCamelCase		=     model(
				    _a				,      attention_mask=_a				,      encoder_hidden_states=_a				,      encoder_attention_mask=_a				,      past_key_values=_a				,      output_hidden_states=_a				,      )['hidden_states'][0]

				# select random slice
				UpperCamelCase		=     ids_tensor((1,)				,      output_from_past.shape[-1]       ).item()
				UpperCamelCase		=     output_from_no_past[:, -3:, random_slice_idx].detach()
				UpperCamelCase		=     output_from_past[:, :, random_slice_idx].detach()

				self.parent.assertTrue(output_from_past_slice.shape[1] == next_tokens.shape[1]       )

				# test that outputs are equal for slice
				self.parent.assertTrue(torch.allclose(_a				,      _a				,      atol=1e-3       )       )



		def __UpperCamelCase ( self       )  ->					str:
				"""simple docstring"""
				UpperCamelCase		=     self.prepare_config_and_inputs()
				(
				    (
				    UpperCamelCase   
				)	,  (
				    UpperCamelCase   
				)	,  (
				    UpperCamelCase   
				)	,  (
				    UpperCamelCase   
				)	,  (
				    UpperCamelCase   
				)	,  (
				    UpperCamelCase   
				)	,  (
				    UpperCamelCase   
				)	,     
				)		=     config_and_inputs
				UpperCamelCase		=     {'input_ids': input_ids, 'attention_mask': input_mask}
				return config, inputs_dict






@require_torch
class 				lowercase					(		UpperCAmelCase__  ,   UpperCAmelCase__  ,   UpperCAmelCase__  ,   unittest.TestCase   ):
		__lowercase       :       Any	     =				(
		    (
		        FalconModel,
		        FalconForCausalLM,
		        FalconForSequenceClassification,
		        FalconForTokenClassification,
		        FalconForQuestionAnswering,
		    )
		    if is_torch_available()
		    else ()
		)
		__lowercase       :       Dict	     =				(FalconForCausalLM,) if is_torch_available() else ()
		__lowercase       :       Optional[int]	     =				(
		    {
		        "feature-extraction": FalconModel,
		        "text-classification": FalconForSequenceClassification,
		        "text-generation": FalconForCausalLM,
		        "question-answering": FalconForQuestionAnswering,
		        "token-classification": FalconForTokenClassification,
		        "zero-shot": FalconForSequenceClassification,
		    }
		    if is_torch_available()
		    else {}
		)
		__lowercase       :       Any	     =				False
		__lowercase       :       str	     =				False



		def __UpperCamelCase ( self       )  ->					Dict:
				"""simple docstring"""
				UpperCamelCase		=     FalconModelTester(self       )
				UpperCamelCase		=     ConfigTester(self				,      config_class=_a				,      hidden_size=37       )



		def __UpperCamelCase ( self       )  ->					List[Any]:
				"""simple docstring"""
				self.config_tester.run_common_tests()



		def __UpperCamelCase ( self       )  ->					List[Any]:
				"""simple docstring"""
				UpperCamelCase		=     self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_model(*_a       )



		def __UpperCamelCase ( self       )  ->					Tuple:
				"""simple docstring"""
				UpperCamelCase	,  *UpperCamelCase		=     self.model_tester.prepare_config_and_inputs()
				for alibi in [True, False]:
						UpperCamelCase		=     alibi
						self.model_tester.create_and_check_model(_a				,      *_a       )



		def __UpperCamelCase ( self       )  ->					int:
				"""simple docstring"""
				UpperCamelCase	,  UpperCamelCase		=     self.model_tester.prepare_config_and_inputs_for_common()
				UpperCamelCase		=     3
				UpperCamelCase		=     input_dict['input_ids']
				UpperCamelCase		=     input_ids.ne(1       ).to(_a       )
				UpperCamelCase		=     ids_tensor([self.model_tester.batch_size]				,      self.model_tester.type_sequence_label_size       )
				UpperCamelCase		=     FalconForSequenceClassification(_a       )
				model.to(_a       )
				model.eval()
				UpperCamelCase		=     model(_a				,      attention_mask=_a				,      labels=_a       )
				self.assertEqual(result.logits.shape				,      (self.model_tester.batch_size, self.model_tester.num_labels)       )



		def __UpperCamelCase ( self       )  ->					List[str]:
				"""simple docstring"""
				UpperCamelCase	,  UpperCamelCase		=     self.model_tester.prepare_config_and_inputs_for_common()
				UpperCamelCase		=     3
				UpperCamelCase		=     'single_label_classification'
				UpperCamelCase		=     input_dict['input_ids']
				UpperCamelCase		=     input_ids.ne(1       ).to(_a       )
				UpperCamelCase		=     ids_tensor([self.model_tester.batch_size]				,      self.model_tester.type_sequence_label_size       )
				UpperCamelCase		=     FalconForSequenceClassification(_a       )
				model.to(_a       )
				model.eval()
				UpperCamelCase		=     model(_a				,      attention_mask=_a				,      labels=_a       )
				self.assertEqual(result.logits.shape				,      (self.model_tester.batch_size, self.model_tester.num_labels)       )



		def __UpperCamelCase ( self       )  ->					Optional[int]:
				"""simple docstring"""
				UpperCamelCase	,  UpperCamelCase		=     self.model_tester.prepare_config_and_inputs_for_common()
				UpperCamelCase		=     input_dict['input_ids']
				UpperCamelCase		=     FalconForCausalLM(_a       )
				model.to(_a       )
				model.eval()
				UpperCamelCase		=     model(_a				,      use_cache=_a       )
				UpperCamelCase		=     input_ids.shape[0]
				UpperCamelCase		=     model._convert_to_rw_cache(result.past_key_values       )
				UpperCamelCase		=     model._convert_cache_to_standard_format(_a				,      _a       )
				for layer in range(len(_a       )       ):
						for tensor_idx in range(2       ):
								self.assertTrue(rw_cache[layer][tensor_idx].ndim == 3       )
								self.assertTrue(result.past_key_values[layer][tensor_idx].ndim == 4       )
								self.assertTrue(
								    torch.all(result.past_key_values[layer][tensor_idx] == standard_cache[layer][tensor_idx]       )       )



		def __UpperCamelCase ( self       )  ->					Any:
				"""simple docstring"""
				UpperCamelCase	,  UpperCamelCase		=     self.model_tester.prepare_config_and_inputs_for_common()
				UpperCamelCase		=     3
				UpperCamelCase		=     'multi_label_classification'
				UpperCamelCase		=     input_dict['input_ids']
				UpperCamelCase		=     input_ids.ne(1       ).to(_a       )
				UpperCamelCase		=     ids_tensor(
				    [self.model_tester.batch_size, config.num_labels]				,      self.model_tester.type_sequence_label_size       ).to(torch.float       )
				UpperCamelCase		=     FalconForSequenceClassification(_a       )
				model.to(_a       )
				model.eval()
				UpperCamelCase		=     model(_a				,      attention_mask=_a				,      labels=_a       )
				self.assertEqual(result.logits.shape				,      (self.model_tester.batch_size, self.model_tester.num_labels)       )



		def __UpperCamelCase ( self       )  ->					Dict:
				"""simple docstring"""
				# Falcon can have different numbers of KV-heads than the number of query heads, so we need
				# to override this test to use the right head counts.
				for model_class in self.all_generative_model_classes:
						UpperCamelCase	,  UpperCamelCase		=     self.model_tester.prepare_config_and_inputs_for_common()

						# If it doesn't support cache, pass the test
						if not hasattr(_a				,      'use_cache'       ):
								return

						UpperCamelCase		=     model_class(_a       ).to(_a       )
						if "use_cache" not in inputs:
								UpperCamelCase		=     True
						UpperCamelCase		=     model(**_a       )

						# If "past_key_values" is not returned, pass the test (e.g. RWKV uses a different cache name and format)
						if "past_key_values" not in outputs:
								return

						UpperCamelCase		=     (
						    getattr(_a				,      'decoder_layers'				,      _a       )
						    or getattr(_a				,      'num_decoder_layers'				,      _a       )
						    or config.num_hidden_layers
						)
						UpperCamelCase		=     getattr(_a				,      'num_kv_heads'				,      config.num_attention_heads       )
						UpperCamelCase		=     getattr(_a				,      'd_model'				,      config.hidden_size       )
						UpperCamelCase		=     embed_dim // num_attention_heads

						UpperCamelCase		=     outputs['past_key_values']
						self.assertEqual(len(_a       )				,      _a       )

						UpperCamelCase	,  UpperCamelCase		=     inputs['input_ids'].shape
						for i in range(_a       ):
								if config.new_decoder_architecture:
										UpperCamelCase		=     config.num_attention_heads
								elif config.multi_query:
										UpperCamelCase		=     1
								self.assertEqual(len(past_kv[0]       )				,      2       )  # K V for the decoder = 2
								self.assertEqual(
								    past_kv[i][0].shape				,      (batch_size, num_attention_heads, seq_length, per_head_embed_dim)       )
								self.assertEqual(
								    past_kv[i][1].shape				,      (batch_size, num_attention_heads, seq_length, per_head_embed_dim)       )






@require_torch
class 				lowercase					(		unittest.TestCase   ):



		@slow
		def __UpperCamelCase ( self       )  ->					Optional[int]:
				"""simple docstring"""
				UpperCamelCase		=     AutoTokenizer.from_pretrained('Rocketknight1/falcon-rw-1b'       )
				UpperCamelCase		=     FalconForCausalLM.from_pretrained('Rocketknight1/falcon-rw-1b'       )
				model.eval()
				model.to(_a       )
				UpperCamelCase		=     tokenizer('My favorite food is'				,      return_tensors='pt'       ).to(_a       )

				UpperCamelCase		=     (
				    'My favorite food is pizza. I love it so much that I have a pizza party every year for my birthday.'
				)

				UpperCamelCase		=     model.generate(**_a				,      do_sample=_a				,      max_new_tokens=19       )
				UpperCamelCase		=     tokenizer.batch_decode(_a       )[0]

				self.assertEqual(_a				,      _a       )



		@slow
		def __UpperCamelCase ( self       )  ->					Any:
				"""simple docstring"""
				# The big models are way too big for the CI, so we use tiny random models that resemble their
				# architectures but with much smaller and fewer layers
				for repo in ["Rocketknight1/tiny-random-falcon-7b", "Rocketknight1/tiny-random-falcon-40b"]:
						UpperCamelCase		=     AutoTokenizer.from_pretrained(_a       )
						UpperCamelCase		=     FalconForCausalLM.from_pretrained(_a       )
						model.eval()
						model.to(_a       )
						UpperCamelCase		=     tokenizer('My favorite food is'				,      return_tensors='pt'       ).to(_a       )

						# We just test that these run without errors - the models are randomly initialized
						# and so the actual text outputs will be garbage
						model.generate(**_a				,      do_sample=_a				,      max_new_tokens=4       )
						model.generate(**_a				,      do_sample=_a				,      max_new_tokens=4       )
						model.generate(**_a				,      num_beams=2				,      max_new_tokens=4       )



		@slow
		def __UpperCamelCase ( self       )  ->					int:
				"""simple docstring"""
				# The big models are way too big for the CI, so we use tiny random models that resemble their
				# architectures but with much smaller and fewer layers
				with torch.no_grad():
						for repo in [
						    "Rocketknight1/falcon-rw-1b",
						    "Rocketknight1/tiny-random-falcon-7b",
						    "Rocketknight1/tiny-random-falcon-40b",
						]:
								UpperCamelCase		=     AutoTokenizer.from_pretrained(_a       )
								UpperCamelCase		=     FalconForCausalLM.from_pretrained(_a       )
								model.eval()
								model.to(device=_a       )
								UpperCamelCase		=     tokenizer('My favorite food is'				,      return_tensors='pt'       ).to(_a       )

								# Test results are the same with and without cache
								UpperCamelCase		=     model.generate(**_a				,      do_sample=_a				,      max_new_tokens=20				,      use_cache=_a       )
								UpperCamelCase		=     model.generate(**_a				,      do_sample=_a				,      max_new_tokens=20				,      use_cache=_a       )
								self.assertTrue((outputs_cache - outputs_no_cache).sum().item() == 0       )






"""simple docstring"""




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     __magic_name__							(       unittest.TestCase				):






				'''simple docstring'''





				def    _lowerCAmelCase				(       self ):





							"""simple docstring"""
							lowerCamelCase			      =					tempfile.mkdtemp()

							# fmt: off
							lowerCamelCase			      =					["""[UNK]""", """[CLS]""", """[SEP]""", """[PAD]""", """[MASK]""", """want""", """##want""", """##ed""", """wa""", """un""", """runn""", """##ing""", """,""", """low""", """lowest"""]
							# fmt: on
							lowerCamelCase			      =					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] ) )

							lowerCamelCase			      =					{
							    """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],
							}
							lowerCamelCase			      =					os.path.join(self.tmpdirname		, _a )
							with open(self.image_processor_file		, """w"""		, encoding="""utf-8""" ) as fp:
										json.dump(_a		, _a )





				def    _lowerCAmelCase				(       self		, **_a ):





							"""simple docstring"""
							return BertTokenizer.from_pretrained(self.tmpdirname		, **_a )





				def    _lowerCAmelCase				(       self		, **_a ):





							"""simple docstring"""
							return ViTImageProcessor.from_pretrained(self.tmpdirname		, **_a )





				def    _lowerCAmelCase				(       self ):





							"""simple docstring"""
							shutil.rmtree(self.tmpdirname )





				def    _lowerCAmelCase				(       self ):





							"""simple docstring"""
							lowerCamelCase			      =					[np.random.randint(255		, size=(3, 30, 400)		, dtype=np.uinta )]

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

							return image_inputs





				def    _lowerCAmelCase				(       self ):





							"""simple docstring"""
							lowerCamelCase			      =					self.get_tokenizer()
							lowerCamelCase			      =					self.get_image_processor()

							lowerCamelCase			      =					VisionTextDualEncoderProcessor(tokenizer=_a		, image_processor=_a )

							processor.save_pretrained(self.tmpdirname )
							lowerCamelCase			      =					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		, _a )





				def    _lowerCAmelCase				(       self ):





							"""simple docstring"""
							lowerCamelCase			      =					VisionTextDualEncoderProcessor(
							    tokenizer=self.get_tokenizer()		, image_processor=self.get_image_processor() )
							processor.save_pretrained(self.tmpdirname )

							lowerCamelCase			      =					self.get_tokenizer(bos_token="""(BOS)"""		, eos_token="""(EOS)""" )
							lowerCamelCase			      =					self.get_image_processor(do_normalize=_a		, padding_value=1.0 )

							lowerCamelCase			      =					VisionTextDualEncoderProcessor.from_pretrained(
							    self.tmpdirname		, bos_token="""(BOS)"""		, eos_token="""(EOS)"""		, do_normalize=_a		, 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		, _a )





				def    _lowerCAmelCase				(       self ):





							"""simple docstring"""
							lowerCamelCase			      =					self.get_image_processor()
							lowerCamelCase			      =					self.get_tokenizer()

							lowerCamelCase			      =					VisionTextDualEncoderProcessor(tokenizer=_a		, image_processor=_a )

							lowerCamelCase			      =					self.prepare_image_inputs()

							lowerCamelCase			      =					image_processor(_a		, return_tensors="""np""" )
							lowerCamelCase			      =					processor(images=_a		, 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 ):





							"""simple docstring"""
							lowerCamelCase			      =					self.get_image_processor()
							lowerCamelCase			      =					self.get_tokenizer()

							lowerCamelCase			      =					VisionTextDualEncoderProcessor(tokenizer=_a		, image_processor=_a )

							lowerCamelCase			      =					"""lower newer"""

							lowerCamelCase			      =					processor(text=_a )

							lowerCamelCase			      =					tokenizer(_a )

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





				def    _lowerCAmelCase				(       self ):





							"""simple docstring"""
							lowerCamelCase			      =					self.get_image_processor()
							lowerCamelCase			      =					self.get_tokenizer()

							lowerCamelCase			      =					VisionTextDualEncoderProcessor(tokenizer=_a		, image_processor=_a )

							lowerCamelCase			      =					"""lower newer"""
							lowerCamelCase			      =					self.prepare_image_inputs()

							lowerCamelCase			      =					processor(text=_a		, images=_a )

							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(_a ):
										processor()





				def    _lowerCAmelCase				(       self ):





							"""simple docstring"""
							lowerCamelCase			      =					self.get_image_processor()
							lowerCamelCase			      =					self.get_tokenizer()

							lowerCamelCase			      =					VisionTextDualEncoderProcessor(tokenizer=_a		, image_processor=_a )

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

							lowerCamelCase			      =					processor.batch_decode(_a )
							lowerCamelCase			      =					tokenizer.batch_decode(_a )

							self.assertListEqual(_a		, _a )





				def    _lowerCAmelCase				(       self ):





							"""simple docstring"""
							lowerCamelCase			      =					self.get_image_processor()
							lowerCamelCase			      =					self.get_tokenizer()

							lowerCamelCase			      =					VisionTextDualEncoderProcessor(tokenizer=_a		, image_processor=_a )

							lowerCamelCase			      =					"""lower newer"""
							lowerCamelCase			      =					self.prepare_image_inputs()

							lowerCamelCase			      =					processor(text=_a		, images=_a )

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



