
from __future__ import annotations

import collections
import tempfile
import unittest

import numpy as np

from transformers.testing_utils import require_tf, require_vision, slow
from transformers.utils import is_tf_available, is_vision_available

from ...test_modeling_tf_common import floats_tensor, ids_tensor, random_attention_mask
from ..bert.test_modeling_tf_bert import TFBertModelTester
from ..clip.test_modeling_tf_clip import TFCLIPVisionModelTester
from ..deit.test_modeling_tf_deit import TFDeiTModelTester
from ..roberta.test_modeling_tf_roberta import TFRobertaModelTester
from ..vit.test_modeling_tf_vit import TFViTModelTester


if is_tf_available():
 from transformers import (
     TFBertModel,
     TFCLIPVisionModel,
     TFDeiTModel,
     TFRobertaModel,
     TFVisionTextDualEncoderModel,
     TFViTModel,
     VisionTextDualEncoderConfig,
 )

if is_vision_available():
 from PIL import Image

 from transformers import VisionTextDualEncoderProcessor

def  __lowerCamelCase					( _lowercase			)       ->      Tuple:
     if isinstance(_lowercase						,     collections.abc.Iterable			):
          return x
     return (x, x)
@require_tf
class       _lowerCAmelCase  :

 """simple docstring"""

 def      __lowerCAmelCase  (						self			:			Optional[int]					, SCREAMING_SNAKE_CASE__			:			Optional[int]					, SCREAMING_SNAKE_CASE__			:			Tuple   ):






      """simple docstring"""



      pass

 def      __lowerCAmelCase  (						self			:			int   ):






      """simple docstring"""



      pass

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






      """simple docstring"""



      pass

 def      __lowerCAmelCase  (						self			:			Dict					, SCREAMING_SNAKE_CASE__			:			Dict					, SCREAMING_SNAKE_CASE__			:			Tuple					, SCREAMING_SNAKE_CASE__			:			Optional[int]					, SCREAMING_SNAKE_CASE__			:			Any					, SCREAMING_SNAKE_CASE__			:			List[str]=None					, **SCREAMING_SNAKE_CASE__			:			Optional[Any]   ):






      """simple docstring"""



      UpperCamelCase						    =					VisionTextDualEncoderConfig.from_vision_text_configs(SCREAMING_SNAKE_CASE__					, SCREAMING_SNAKE_CASE__   )

      UpperCamelCase						    =					TFVisionTextDualEncoderModel(SCREAMING_SNAKE_CASE__   )

      UpperCamelCase						    =					model(input_ids=SCREAMING_SNAKE_CASE__					, pixel_values=SCREAMING_SNAKE_CASE__					, attention_mask=SCREAMING_SNAKE_CASE__   )

      self.assertEqual(output['text_embeds'].shape					, (input_ids.shape[0], config.projection_dim)   )
      self.assertEqual(output['image_embeds'].shape					, (pixel_values.shape[0], config.projection_dim)   )

 def      __lowerCAmelCase  (						self			:			List[str]					, SCREAMING_SNAKE_CASE__			:			Optional[Any]					, SCREAMING_SNAKE_CASE__			:			List[str]					, SCREAMING_SNAKE_CASE__			:			int					, SCREAMING_SNAKE_CASE__			:			Any					, SCREAMING_SNAKE_CASE__			:			Tuple=None					, **SCREAMING_SNAKE_CASE__			:			Optional[Any]   ):






      """simple docstring"""



      UpperCamelCase    ,		UpperCamelCase						    =					self.get_vision_text_model(SCREAMING_SNAKE_CASE__					, SCREAMING_SNAKE_CASE__   )
      UpperCamelCase						    =					TFVisionTextDualEncoderModel(vision_model=SCREAMING_SNAKE_CASE__					, text_model=SCREAMING_SNAKE_CASE__   )

      UpperCamelCase						    =					model(input_ids=SCREAMING_SNAKE_CASE__					, pixel_values=SCREAMING_SNAKE_CASE__					, attention_mask=SCREAMING_SNAKE_CASE__   )

      self.assertEqual(output['text_embeds'].shape					, (input_ids.shape[0], model.config.projection_dim)   )
      self.assertEqual(output['image_embeds'].shape					, (pixel_values.shape[0], model.config.projection_dim)   )

 def      __lowerCAmelCase  (						self			:			Optional[int]					, SCREAMING_SNAKE_CASE__			:			int					, SCREAMING_SNAKE_CASE__			:			Dict					, SCREAMING_SNAKE_CASE__			:			List[Any]					, SCREAMING_SNAKE_CASE__			:			Union[str, Any]					, SCREAMING_SNAKE_CASE__			:			str=None					, **SCREAMING_SNAKE_CASE__			:			int   ):






      """simple docstring"""



      UpperCamelCase    ,		UpperCamelCase						    =					self.get_vision_text_model(SCREAMING_SNAKE_CASE__					, SCREAMING_SNAKE_CASE__   )
      UpperCamelCase						    =					{'vision_model': vision_model, 'text_model': text_model}
      UpperCamelCase						    =					TFVisionTextDualEncoderModel.from_vision_text_pretrained(**SCREAMING_SNAKE_CASE__   )

      UpperCamelCase						    =					model(input_ids=SCREAMING_SNAKE_CASE__					, pixel_values=SCREAMING_SNAKE_CASE__					, attention_mask=SCREAMING_SNAKE_CASE__   )

      self.assertEqual(output['text_embeds'].shape					, (input_ids.shape[0], model.config.projection_dim)   )
      self.assertEqual(output['image_embeds'].shape					, (pixel_values.shape[0], model.config.projection_dim)   )

 def      __lowerCAmelCase  (						self			:			List[str]					, SCREAMING_SNAKE_CASE__			:			Any					, SCREAMING_SNAKE_CASE__			:			Dict					, SCREAMING_SNAKE_CASE__			:			int					, SCREAMING_SNAKE_CASE__			:			Any					, SCREAMING_SNAKE_CASE__			:			Union[str, Any]=None					, **SCREAMING_SNAKE_CASE__			:			Optional[int]   ):






      """simple docstring"""



      UpperCamelCase    ,		UpperCamelCase						    =					self.get_vision_text_model(SCREAMING_SNAKE_CASE__					, SCREAMING_SNAKE_CASE__   )
      UpperCamelCase						    =					TFVisionTextDualEncoderModel(vision_model=SCREAMING_SNAKE_CASE__					, text_model=SCREAMING_SNAKE_CASE__   )

      UpperCamelCase						    =					model(input_ids=SCREAMING_SNAKE_CASE__					, pixel_values=SCREAMING_SNAKE_CASE__					, attention_mask=SCREAMING_SNAKE_CASE__   )
      UpperCamelCase						    =					output[0].numpy()

      with tempfile.TemporaryDirectory() as tmpdirname:
           model.save_pretrained(SCREAMING_SNAKE_CASE__   )
           UpperCamelCase						    =					TFVisionTextDualEncoderModel.from_pretrained(SCREAMING_SNAKE_CASE__   )

           UpperCamelCase						    =					model(input_ids=SCREAMING_SNAKE_CASE__					, pixel_values=SCREAMING_SNAKE_CASE__					, attention_mask=SCREAMING_SNAKE_CASE__   )
           UpperCamelCase						    =					after_output[0].numpy()
           UpperCamelCase						    =					np.amax(np.abs(out_a - out_a   )   )
           self.assertLessEqual(SCREAMING_SNAKE_CASE__					, 1e-5   )

 def      __lowerCAmelCase  (						self			:			Any					, SCREAMING_SNAKE_CASE__			:			Optional[int]					, SCREAMING_SNAKE_CASE__			:			List[Any]					, SCREAMING_SNAKE_CASE__			:			Dict					, SCREAMING_SNAKE_CASE__			:			Any					, SCREAMING_SNAKE_CASE__			:			Tuple=None					, **SCREAMING_SNAKE_CASE__			:			Dict   ):






      """simple docstring"""



      UpperCamelCase    ,		UpperCamelCase						    =					self.get_vision_text_model(SCREAMING_SNAKE_CASE__					, SCREAMING_SNAKE_CASE__   )
      UpperCamelCase						    =					TFVisionTextDualEncoderModel(vision_model=SCREAMING_SNAKE_CASE__					, text_model=SCREAMING_SNAKE_CASE__   )

      UpperCamelCase						    =					model(
          input_ids=SCREAMING_SNAKE_CASE__					, pixel_values=SCREAMING_SNAKE_CASE__					, attention_mask=SCREAMING_SNAKE_CASE__					, output_attentions=SCREAMING_SNAKE_CASE__   )

      UpperCamelCase						    =					output.vision_model_output.attentions
      self.assertEqual(len(SCREAMING_SNAKE_CASE__   )					, vision_config.num_hidden_layers   )

      # in ViT, the seq_len equals the number of patches + 1 (we add 1 for the [CLS] token)
      UpperCamelCase						    =					to_atuple(vision_model.config.image_size   )
      UpperCamelCase						    =					to_atuple(vision_model.config.patch_size   )
      UpperCamelCase						    =					(image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])
      UpperCamelCase						    =					num_patches + 1
      self.assertEqual(vision_attentions[0].shape[-3:]					, (vision_config.num_attention_heads, seq_len, seq_len)   )

      UpperCamelCase						    =					output.text_model_output.attentions
      self.assertEqual(len(SCREAMING_SNAKE_CASE__   )					, text_config.num_hidden_layers   )

      self.assertEqual(
          text_attentions[0].shape[-3:]					, (text_config.num_attention_heads, input_ids.shape[-1], input_ids.shape[-1])					, )

 def      __lowerCAmelCase  (						self			:			Optional[int]					, SCREAMING_SNAKE_CASE__			:			np.ndarray					, SCREAMING_SNAKE_CASE__			:			np.ndarray					, SCREAMING_SNAKE_CASE__			:			float   ):






      """simple docstring"""



      UpperCamelCase						    =					np.abs((a - b)   ).max()
      self.assertLessEqual(SCREAMING_SNAKE_CASE__					, SCREAMING_SNAKE_CASE__					, F'Difference between torch and flax is {diff} (>= {tol}).'   )

 def      __lowerCAmelCase  (						self			:			Any   ):






      """simple docstring"""



      UpperCamelCase						    =					self.prepare_config_and_inputs()
      self.check_vision_text_dual_encoder_model(**SCREAMING_SNAKE_CASE__   )

 def      __lowerCAmelCase  (						self			:			int   ):






      """simple docstring"""



      UpperCamelCase						    =					self.prepare_config_and_inputs()
      self.check_model_from_pretrained_configs(**SCREAMING_SNAKE_CASE__   )

 def      __lowerCAmelCase  (						self			:			Optional[Any]   ):






      """simple docstring"""



      UpperCamelCase						    =					self.prepare_config_and_inputs()
      self.check_vision_text_dual_encoder_from_pretrained(**SCREAMING_SNAKE_CASE__   )

 def      __lowerCAmelCase  (						self			:			List[Any]   ):






      """simple docstring"""



      UpperCamelCase						    =					self.prepare_config_and_inputs()
      self.check_save_load(**SCREAMING_SNAKE_CASE__   )

 def      __lowerCAmelCase  (						self			:			Dict   ):






      """simple docstring"""



      UpperCamelCase						    =					self.prepare_config_and_inputs()
      self.check_vision_text_output_attention(**SCREAMING_SNAKE_CASE__   )






 @slow
 def      __lowerCAmelCase  (						self			:			Optional[int]   ):






      """simple docstring"""



      UpperCamelCase    ,		UpperCamelCase						    =					self.get_pretrained_model_and_inputs()

      UpperCamelCase						    =					model_a(**SCREAMING_SNAKE_CASE__   )
      UpperCamelCase						    =					outputs[0].numpy()

      with tempfile.TemporaryDirectory() as tmp_dirname:
           model_a.save_pretrained(SCREAMING_SNAKE_CASE__   )
           UpperCamelCase						    =					TFVisionTextDualEncoderModel.from_pretrained(SCREAMING_SNAKE_CASE__   )

           UpperCamelCase						    =					model_a(**SCREAMING_SNAKE_CASE__   )
           UpperCamelCase						    =					after_outputs[0].numpy()
           UpperCamelCase						    =					np.amax(np.abs(out_a - out_a   )   )
           self.assertLessEqual(SCREAMING_SNAKE_CASE__					, 1e-5   )




@require_tf
class       _lowerCAmelCase  (		__magic_name__			,	unittest.TestCase							):

 """simple docstring"""

 def      __lowerCAmelCase  (						self			:			List[str]   ):






      """simple docstring"""



      UpperCamelCase						    =					TFVisionTextDualEncoderModel.from_vision_text_pretrained(
          'hf-internal-testing/tiny-random-vit'					, 'hf-internal-testing/tiny-random-bert'   )
      UpperCamelCase						    =					13
      UpperCamelCase						    =					floats_tensor(
          [
              batch_size,
              model.vision_model.config.num_channels,
              model.vision_model.config.image_size,
              model.vision_model.config.image_size,
          ]   )
      UpperCamelCase						    =					ids_tensor([batch_size, 4]					, model.text_model.config.vocab_size   )
      UpperCamelCase						    =					random_attention_mask([batch_size, 4]   )
      UpperCamelCase						    =					{'pixel_values': pixel_values, 'input_ids': input_ids, 'attention_mask': attention_mask}

      return model, inputs

 def      __lowerCAmelCase  (						self			:			Optional[Any]					, SCREAMING_SNAKE_CASE__			:			Union[str, Any]					, SCREAMING_SNAKE_CASE__			:			str   ):






      """simple docstring"""



      UpperCamelCase						    =					TFViTModel(SCREAMING_SNAKE_CASE__					, name='vision_model'   )
      UpperCamelCase						    =					TFBertModel(SCREAMING_SNAKE_CASE__					, name='text_model'   )
      return vision_model, text_model






 def      __lowerCAmelCase  (						self			:			Tuple   ):






      """simple docstring"""



      UpperCamelCase						    =					TFViTModelTester(self   )
      UpperCamelCase						    =					TFBertModelTester(self   )
      UpperCamelCase						    =					vit_model_tester.prepare_config_and_inputs()
      UpperCamelCase						    =					bert_model_tester.prepare_config_and_inputs()

      UpperCamelCase    ,		UpperCamelCase    ,		UpperCamelCase						    =					vision_config_and_inputs

      (
          (
          UpperCamelCase
      )    ,		(
          UpperCamelCase
      )    ,		(
          UpperCamelCase
      )    ,		(
          UpperCamelCase
      )    ,		(
          UpperCamelCase
      )    ,		(
          UpperCamelCase
      )    ,		(
          UpperCamelCase
      )    ,		
      )						    =					text_config_and_inputs

      return {
          "text_config": text_config,
          "vision_config": vision_config,
          "pixel_values": pixel_values,
          "attention_mask": input_mask,
          "input_ids": input_ids,
          "text_token_type_ids": token_type_ids,
          "text_sequence_labels": sequence_labels,
          "text_token_labels": token_labels,
          "text_choice_labels": choice_labels,
      }




@require_tf
class       _lowerCAmelCase  (		__magic_name__			,	unittest.TestCase							):

 """simple docstring"""

 def      __lowerCAmelCase  (						self			:			int   ):






      """simple docstring"""



      UpperCamelCase						    =					TFVisionTextDualEncoderModel.from_vision_text_pretrained(
          'Rocketknight1/tiny-random-deit-tf'					, 'hf-internal-testing/tiny-random-roberta'   )
      UpperCamelCase						    =					13
      UpperCamelCase						    =					floats_tensor(
          [
              batch_size,
              model.vision_model.config.num_channels,
              model.vision_model.config.image_size,
              model.vision_model.config.image_size,
          ]   )
      UpperCamelCase						    =					ids_tensor([batch_size, 4]					, model.text_model.config.vocab_size   )
      UpperCamelCase						    =					random_attention_mask([batch_size, 4]   )
      UpperCamelCase						    =					{'pixel_values': pixel_values, 'input_ids': input_ids, 'attention_mask': attention_mask}

      return model, inputs

 def      __lowerCAmelCase  (						self			:			List[Any]					, SCREAMING_SNAKE_CASE__			:			str					, SCREAMING_SNAKE_CASE__			:			Union[str, Any]					, SCREAMING_SNAKE_CASE__			:			Tuple					, SCREAMING_SNAKE_CASE__			:			List[Any]					, SCREAMING_SNAKE_CASE__			:			Any=None					, **SCREAMING_SNAKE_CASE__			:			str   ):






      """simple docstring"""



      UpperCamelCase    ,		UpperCamelCase						    =					self.get_vision_text_model(SCREAMING_SNAKE_CASE__					, SCREAMING_SNAKE_CASE__   )
      UpperCamelCase						    =					TFVisionTextDualEncoderModel(vision_model=SCREAMING_SNAKE_CASE__					, text_model=SCREAMING_SNAKE_CASE__   )

      UpperCamelCase						    =					model(
          input_ids=SCREAMING_SNAKE_CASE__					, pixel_values=SCREAMING_SNAKE_CASE__					, attention_mask=SCREAMING_SNAKE_CASE__					, output_attentions=SCREAMING_SNAKE_CASE__   )

      UpperCamelCase						    =					output.vision_model_output.attentions
      self.assertEqual(len(SCREAMING_SNAKE_CASE__   )					, vision_config.num_hidden_layers   )

      # in DEiT, the seq_len equals the number of patches + 2 (we add 2 for the [CLS] and distillation tokens)
      UpperCamelCase						    =					to_atuple(vision_model.config.image_size   )
      UpperCamelCase						    =					to_atuple(vision_model.config.patch_size   )
      UpperCamelCase						    =					(image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])
      UpperCamelCase						    =					num_patches + 2
      self.assertEqual(vision_attentions[0].shape[-3:]					, (vision_config.num_attention_heads, seq_len, seq_len)   )

      UpperCamelCase						    =					output.text_model_output.attentions
      self.assertEqual(len(SCREAMING_SNAKE_CASE__   )					, text_config.num_hidden_layers   )

      self.assertEqual(
          text_attentions[0].shape[-3:]					, (text_config.num_attention_heads, input_ids.shape[-1], input_ids.shape[-1])					, )

 def      __lowerCAmelCase  (						self			:			str					, SCREAMING_SNAKE_CASE__			:			int					, SCREAMING_SNAKE_CASE__			:			Tuple   ):






      """simple docstring"""



      UpperCamelCase						    =					TFDeiTModel(SCREAMING_SNAKE_CASE__					, name='vision_model'   )
      UpperCamelCase						    =					TFRobertaModel(SCREAMING_SNAKE_CASE__					, name='text_model'   )
      return vision_model, text_model






 def      __lowerCAmelCase  (						self			:			Any   ):






      """simple docstring"""



      UpperCamelCase						    =					TFDeiTModelTester(self   )
      UpperCamelCase						    =					TFRobertaModelTester(self   )
      UpperCamelCase						    =					vit_model_tester.prepare_config_and_inputs()
      UpperCamelCase						    =					bert_model_tester.prepare_config_and_inputs()

      UpperCamelCase    ,		UpperCamelCase    ,		UpperCamelCase						    =					vision_config_and_inputs

      (
          (
          UpperCamelCase
      )    ,		(
          UpperCamelCase
      )    ,		(
          UpperCamelCase
      )    ,		(
          UpperCamelCase
      )    ,		(
          UpperCamelCase
      )    ,		(
          UpperCamelCase
      )    ,		(
          UpperCamelCase
      )    ,		
      )						    =					text_config_and_inputs

      return {
          "text_config": text_config,
          "vision_config": vision_config,
          "pixel_values": pixel_values,
          "attention_mask": input_mask,
          "input_ids": input_ids,
          "text_token_type_ids": token_type_ids,
          "text_sequence_labels": sequence_labels,
          "text_token_labels": token_labels,
          "text_choice_labels": choice_labels,
      }




@require_tf
class       _lowerCAmelCase  (		__magic_name__			,	unittest.TestCase							):

 """simple docstring"""

 def      __lowerCAmelCase  (						self			:			int   ):






      """simple docstring"""



      UpperCamelCase						    =					TFVisionTextDualEncoderModel.from_vision_text_pretrained(
          'Rocketknight1/tiny-random-clip-tf'					, 'hf-internal-testing/tiny-random-bert'   )
      UpperCamelCase						    =					13
      UpperCamelCase						    =					floats_tensor(
          [
              batch_size,
              model.vision_model.config.num_channels,
              model.vision_model.config.image_size,
              model.vision_model.config.image_size,
          ]   )
      UpperCamelCase						    =					ids_tensor([batch_size, 4]					, model.text_model.config.vocab_size   )
      UpperCamelCase						    =					random_attention_mask([batch_size, 4]   )
      UpperCamelCase						    =					{'pixel_values': pixel_values, 'input_ids': input_ids, 'attention_mask': attention_mask}

      return model, inputs

 def      __lowerCAmelCase  (						self			:			Union[str, Any]					, SCREAMING_SNAKE_CASE__			:			Dict					, SCREAMING_SNAKE_CASE__			:			Union[str, Any]   ):






      """simple docstring"""



      UpperCamelCase						    =					TFCLIPVisionModel(SCREAMING_SNAKE_CASE__					, name='vision_model'   )
      UpperCamelCase						    =					TFBertModel(SCREAMING_SNAKE_CASE__					, name='text_model'   )
      return vision_model, text_model






 def      __lowerCAmelCase  (						self			:			str   ):






      """simple docstring"""



      UpperCamelCase						    =					TFCLIPVisionModelTester(self   )
      UpperCamelCase						    =					TFBertModelTester(self   )
      UpperCamelCase						    =					clip_model_tester.prepare_config_and_inputs()
      UpperCamelCase						    =					bert_model_tester.prepare_config_and_inputs()

      UpperCamelCase    ,		UpperCamelCase						    =					vision_config_and_inputs

      (
          (
          UpperCamelCase
      )    ,		(
          UpperCamelCase
      )    ,		(
          UpperCamelCase
      )    ,		(
          UpperCamelCase
      )    ,		(
          UpperCamelCase
      )    ,		(
          UpperCamelCase
      )    ,		(
          UpperCamelCase
      )    ,		
      )						    =					text_config_and_inputs

      return {
          "text_config": text_config,
          "vision_config": vision_config,
          "pixel_values": pixel_values,
          "attention_mask": input_mask,
          "input_ids": input_ids,
          "text_token_type_ids": token_type_ids,
          "text_sequence_labels": sequence_labels,
          "text_token_labels": token_labels,
          "text_choice_labels": choice_labels,
      }




@require_vision
@require_tf
class       _lowerCAmelCase  (		unittest.TestCase							):

 """simple docstring"""

 @slow
 def      __lowerCAmelCase  (						self			:			Optional[Any]   ):






      """simple docstring"""



      UpperCamelCase						    =					TFVisionTextDualEncoderModel.from_pretrained(
          'clip-italian/clip-italian'					, logit_scale_init_value=1.0					, from_pt=SCREAMING_SNAKE_CASE__   )
      UpperCamelCase						    =					VisionTextDualEncoderProcessor.from_pretrained('clip-italian/clip-italian'   )

      UpperCamelCase						    =					Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'   )
      UpperCamelCase						    =					processor(
          text=['una foto di un gatto', 'una foto di un cane']					, images=SCREAMING_SNAKE_CASE__					, padding=SCREAMING_SNAKE_CASE__					, return_tensors='np'   )

      UpperCamelCase						    =					model(**SCREAMING_SNAKE_CASE__   )

      # verify the logits
      self.assertEqual(outputs.logits_per_image.shape					, (inputs.pixel_values.shape[0], inputs.input_ids.shape[0])   )
      self.assertEqual(
          outputs.logits_per_text.shape					, (inputs.input_ids.shape[0], inputs.pixel_values.shape[0])					, )

      UpperCamelCase						    =					np.array([[1.2284727, 0.3104122]]   )

      self.assertTrue(np.allclose(outputs.logits_per_image.numpy()					, SCREAMING_SNAKE_CASE__					, atol=1e-3   )   )




def  __lowerCamelCase					( _lowercase			)       ->      list:
     UpperCamelCase						    =					len(_lowercase			)
     for _ in range(_lowercase			):
          for i in range(_ % 2						,     arr_size - 1						,     2			):
               if arr[i + 1] < arr[i]:
                    UpperCamelCase    ,		UpperCamelCase						    =					arr[i + 1], arr[i]

     return arr


if __name__ == "__main__":
 _snake_case      = list(range(10, 0, -1))
 print(F"Original: {arr}. Sorted: {odd_even_transposition(arr)}")


