




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 			__magic_name__				( A		:					str   ):






			'''simple docstring'''







			if isinstance(A,  collections.abc.Iterable   ):
						return x
			return (x, x)




@require_tf
class     snake_case__							:
				"""simple docstring"""



				def 							__UpperCAmelCase							(      self				:     int					,      __lowerCamelCase				:     Union[str, Any]					,      __lowerCamelCase				:     List[Any]							)					->     Optional[Any]:
							pass





				def 							__UpperCAmelCase							(      self				:     Union[str, Any]							)					->     Any:
							pass





				def 							__UpperCAmelCase							(      self				:     int							)					->     str:
							pass





				def 							__UpperCAmelCase							(      self				:     Optional[Any]					,      __lowerCamelCase				:     Dict					,      __lowerCamelCase				:     Tuple					,      __lowerCamelCase				:     Tuple					,      __lowerCamelCase				:     Tuple					,      __lowerCamelCase				:     List[Any]=None					,      **__lowerCamelCase				:     List[Any]							)					->     List[str]:
							a    =			VisionTextDualEncoderConfig.from_vision_text_configs(__lowerCamelCase					,      __lowerCamelCase							)

							a    =			TFVisionTextDualEncoderModel(__lowerCamelCase							)

							a    =			model(input_ids=__lowerCamelCase					,      pixel_values=__lowerCamelCase					,      attention_mask=__lowerCamelCase							)

							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 							__UpperCAmelCase							(      self				:     Optional[int]					,      __lowerCamelCase				:     int					,      __lowerCamelCase				:     Optional[int]					,      __lowerCamelCase				:     Optional[int]					,      __lowerCamelCase				:     Optional[Any]					,      __lowerCamelCase				:     List[Any]=None					,      **__lowerCamelCase				:     str							)					->     List[Any]:
							a    ,		a    =			self.get_vision_text_model(__lowerCamelCase					,      __lowerCamelCase							)
							a    =			TFVisionTextDualEncoderModel(vision_model=__lowerCamelCase					,      text_model=__lowerCamelCase							)

							a    =			model(input_ids=__lowerCamelCase					,      pixel_values=__lowerCamelCase					,      attention_mask=__lowerCamelCase							)

							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 							__UpperCAmelCase							(      self				:     int					,      __lowerCamelCase				:     List[str]					,      __lowerCamelCase				:     List[str]					,      __lowerCamelCase				:     List[str]					,      __lowerCamelCase				:     List[str]					,      __lowerCamelCase				:     int=None					,      **__lowerCamelCase				:     Tuple							)					->     Union[str, Any]:
							a    ,		a    =			self.get_vision_text_model(__lowerCamelCase					,      __lowerCamelCase							)
							a    =			{"vision_model": vision_model, "text_model": text_model}
							a    =			TFVisionTextDualEncoderModel.from_vision_text_pretrained(**__lowerCamelCase							)

							a    =			model(input_ids=__lowerCamelCase					,      pixel_values=__lowerCamelCase					,      attention_mask=__lowerCamelCase							)

							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 							__UpperCAmelCase							(      self				:     str					,      __lowerCamelCase				:     Union[str, Any]					,      __lowerCamelCase				:     str					,      __lowerCamelCase				:     Union[str, Any]					,      __lowerCamelCase				:     Union[str, Any]					,      __lowerCamelCase				:     Optional[int]=None					,      **__lowerCamelCase				:     Tuple							)					->     List[Any]:
							a    ,		a    =			self.get_vision_text_model(__lowerCamelCase					,      __lowerCamelCase							)
							a    =			TFVisionTextDualEncoderModel(vision_model=__lowerCamelCase					,      text_model=__lowerCamelCase							)

							a    =			model(input_ids=__lowerCamelCase					,      pixel_values=__lowerCamelCase					,      attention_mask=__lowerCamelCase							)
							a    =			output[0].numpy()

							with tempfile.TemporaryDirectory() as tmpdirname:
										model.save_pretrained(__lowerCamelCase							)
										a    =			TFVisionTextDualEncoderModel.from_pretrained(__lowerCamelCase							)

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





				def 							__UpperCAmelCase							(      self				:     Dict					,      __lowerCamelCase				:     Union[str, Any]					,      __lowerCamelCase				:     Union[str, Any]					,      __lowerCamelCase				:     Optional[int]					,      __lowerCamelCase				:     List[str]					,      __lowerCamelCase				:     List[Any]=None					,      **__lowerCamelCase				:     Optional[int]							)					->     Union[str, Any]:
							a    ,		a    =			self.get_vision_text_model(__lowerCamelCase					,      __lowerCamelCase							)
							a    =			TFVisionTextDualEncoderModel(vision_model=__lowerCamelCase					,      text_model=__lowerCamelCase							)

							a    =			model(
							    input_ids=__lowerCamelCase					,      pixel_values=__lowerCamelCase					,      attention_mask=__lowerCamelCase					,      output_attentions=__lowerCamelCase							)

							a    =			output.vision_model_output.attentions
							self.assertEqual(len(__lowerCamelCase							)					,      vision_config.num_hidden_layers							)

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

							a    =			output.text_model_output.attentions
							self.assertEqual(len(__lowerCamelCase							)					,      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 							__UpperCAmelCase							(      self				:     Tuple					,      __lowerCamelCase				:     np.ndarray					,      __lowerCamelCase				:     np.ndarray					,      __lowerCamelCase				:     float							)					->     str:
							a    =			np.abs((a - b)							).max()
							self.assertLessEqual(__lowerCamelCase					,      __lowerCamelCase					,      f"""Difference between torch and flax is {diff} (>= {tol})."""							)





				def 							__UpperCAmelCase							(      self				:     int							)					->     Any:
							a    =			self.prepare_config_and_inputs()
							self.check_vision_text_dual_encoder_model(**__lowerCamelCase							)





				def 							__UpperCAmelCase							(      self				:     int							)					->     Dict:
							a    =			self.prepare_config_and_inputs()
							self.check_model_from_pretrained_configs(**__lowerCamelCase							)





				def 							__UpperCAmelCase							(      self				:     Any							)					->     Optional[Any]:
							a    =			self.prepare_config_and_inputs()
							self.check_vision_text_dual_encoder_from_pretrained(**__lowerCamelCase							)





				def 							__UpperCAmelCase							(      self				:     Any							)					->     Union[str, Any]:
							a    =			self.prepare_config_and_inputs()
							self.check_save_load(**__lowerCamelCase							)





				def 							__UpperCAmelCase							(      self				:     Optional[int]							)					->     Tuple:
							a    =			self.prepare_config_and_inputs()
							self.check_vision_text_output_attention(**__lowerCamelCase							)





				@slow
				def 							__UpperCAmelCase							(      self				:     List[Any]							)					->     Tuple:
							a    ,		a    =			self.get_pretrained_model_and_inputs()

							a    =			model_a(**__lowerCamelCase							)
							a    =			outputs[0].numpy()

							with tempfile.TemporaryDirectory() as tmp_dirname:
										model_a.save_pretrained(__lowerCamelCase							)
										a    =			TFVisionTextDualEncoderModel.from_pretrained(__lowerCamelCase							)

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




@require_tf
class     snake_case__							(_UpperCamelCase    ,       unittest.TestCase   ):
				"""simple docstring"""



				def 							__UpperCAmelCase							(      self				:     str							)					->     Union[str, Any]:
							a    =			TFVisionTextDualEncoderModel.from_vision_text_pretrained(
							    "hf-internal-testing/tiny-random-vit"					,      "hf-internal-testing/tiny-random-bert"							)
							a    =			13
							a    =			floats_tensor(
							    [
							        batch_size,
							        model.vision_model.config.num_channels,
							        model.vision_model.config.image_size,
							        model.vision_model.config.image_size,
							    ]							)
							a    =			ids_tensor([batch_size, 4]					,      model.text_model.config.vocab_size							)
							a    =			random_attention_mask([batch_size, 4]							)
							a    =			{"pixel_values": pixel_values, "input_ids": input_ids, "attention_mask": attention_mask}

							return model, inputs





				def 							__UpperCAmelCase							(      self				:     List[Any]					,      __lowerCamelCase				:     List[str]					,      __lowerCamelCase				:     Union[str, Any]							)					->     int:
							a    =			TFViTModel(__lowerCamelCase					,      name="vision_model"							)
							a    =			TFBertModel(__lowerCamelCase					,      name="text_model"							)
							return vision_model, text_model





				def 							__UpperCAmelCase							(      self				:     Optional[int]							)					->     List[Any]:
							a    =			TFViTModelTester(self							)
							a    =			TFBertModelTester(self							)
							a    =			vit_model_tester.prepare_config_and_inputs()
							a    =			bert_model_tester.prepare_config_and_inputs()

							a    ,		a    ,		a    =			vision_config_and_inputs

							(
							    (
							    a
							)    ,		(
							    a
							)    ,		(
							    a
							)    ,		(
							    a
							)    ,		(
							    a
							)    ,		(
							    a
							)    ,		(
							    a
							)    ,		
							)    =			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     snake_case__							(_UpperCamelCase    ,       unittest.TestCase   ):
				"""simple docstring"""



				def 							__UpperCAmelCase							(      self				:     Any							)					->     List[str]:
							# DeiT repo doesn't have TF weights, but we don't actually use the weights at all so let's
							# just reinitialize it.
							a    =			TFVisionTextDualEncoderModel.from_vision_text_pretrained(
							    "Rocketknight1/tiny-random-deit-tf"					,      "hf-internal-testing/tiny-random-roberta"							)
							a    =			13
							a    =			floats_tensor(
							    [
							        batch_size,
							        model.vision_model.config.num_channels,
							        model.vision_model.config.image_size,
							        model.vision_model.config.image_size,
							    ]							)
							a    =			ids_tensor([batch_size, 4]					,      model.text_model.config.vocab_size							)
							a    =			random_attention_mask([batch_size, 4]							)
							a    =			{"pixel_values": pixel_values, "input_ids": input_ids, "attention_mask": attention_mask}

							return model, inputs





				def 							__UpperCAmelCase							(      self				:     str					,      __lowerCamelCase				:     int					,      __lowerCamelCase				:     Any					,      __lowerCamelCase				:     List[str]					,      __lowerCamelCase				:     str					,      __lowerCamelCase				:     List[str]=None					,      **__lowerCamelCase				:     List[Any]							)					->     Dict:
							a    ,		a    =			self.get_vision_text_model(__lowerCamelCase					,      __lowerCamelCase							)
							a    =			TFVisionTextDualEncoderModel(vision_model=__lowerCamelCase					,      text_model=__lowerCamelCase							)

							a    =			model(
							    input_ids=__lowerCamelCase					,      pixel_values=__lowerCamelCase					,      attention_mask=__lowerCamelCase					,      output_attentions=__lowerCamelCase							)

							a    =			output.vision_model_output.attentions
							self.assertEqual(len(__lowerCamelCase							)					,      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)
							a    =			to_atuple(vision_model.config.image_size							)
							a    =			to_atuple(vision_model.config.patch_size							)
							a    =			(image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])
							a    =			num_patches + 2
							self.assertEqual(vision_attentions[0].shape[-3:]					,      (vision_config.num_attention_heads, seq_len, seq_len)							)

							a    =			output.text_model_output.attentions
							self.assertEqual(len(__lowerCamelCase							)					,      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 							__UpperCAmelCase							(      self				:     str					,      __lowerCamelCase				:     Optional[Any]					,      __lowerCamelCase				:     Optional[int]							)					->     Any:
							a    =			TFDeiTModel(__lowerCamelCase					,      name="vision_model"							)
							a    =			TFRobertaModel(__lowerCamelCase					,      name="text_model"							)
							return vision_model, text_model





				def 							__UpperCAmelCase							(      self				:     Union[str, Any]							)					->     Union[str, Any]:
							a    =			TFDeiTModelTester(self							)
							a    =			TFRobertaModelTester(self							)
							a    =			vit_model_tester.prepare_config_and_inputs()
							a    =			bert_model_tester.prepare_config_and_inputs()

							a    ,		a    ,		a    =			vision_config_and_inputs

							(
							    (
							    a
							)    ,		(
							    a
							)    ,		(
							    a
							)    ,		(
							    a
							)    ,		(
							    a
							)    ,		(
							    a
							)    ,		(
							    a
							)    ,		
							)    =			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     snake_case__							(_UpperCamelCase    ,       unittest.TestCase   ):
				"""simple docstring"""



				def 							__UpperCAmelCase							(      self				:     Optional[Any]							)					->     Optional[int]:
							a    =			TFVisionTextDualEncoderModel.from_vision_text_pretrained(
							    "Rocketknight1/tiny-random-clip-tf"					,      "hf-internal-testing/tiny-random-bert"							)
							a    =			13
							a    =			floats_tensor(
							    [
							        batch_size,
							        model.vision_model.config.num_channels,
							        model.vision_model.config.image_size,
							        model.vision_model.config.image_size,
							    ]							)
							a    =			ids_tensor([batch_size, 4]					,      model.text_model.config.vocab_size							)
							a    =			random_attention_mask([batch_size, 4]							)
							a    =			{"pixel_values": pixel_values, "input_ids": input_ids, "attention_mask": attention_mask}

							return model, inputs





				def 							__UpperCAmelCase							(      self				:     List[Any]					,      __lowerCamelCase				:     Union[str, Any]					,      __lowerCamelCase				:     List[str]							)					->     int:
							a    =			TFCLIPVisionModel(__lowerCamelCase					,      name="vision_model"							)
							a    =			TFBertModel(__lowerCamelCase					,      name="text_model"							)
							return vision_model, text_model





				def 							__UpperCAmelCase							(      self				:     Tuple							)					->     Dict:
							a    =			TFCLIPVisionModelTester(self							)
							a    =			TFBertModelTester(self							)
							a    =			clip_model_tester.prepare_config_and_inputs()
							a    =			bert_model_tester.prepare_config_and_inputs()

							a    ,		a    =			vision_config_and_inputs

							(
							    (
							    a
							)    ,		(
							    a
							)    ,		(
							    a
							)    ,		(
							    a
							)    ,		(
							    a
							)    ,		(
							    a
							)    ,		(
							    a
							)    ,		
							)    =			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     snake_case__							(unittest.TestCase   ):
				"""simple docstring"""



				@slow
				def 							__UpperCAmelCase							(      self				:     List[str]							)					->     Union[str, Any]:
							a    =			TFVisionTextDualEncoderModel.from_pretrained(
							    "clip-italian/clip-italian"					,      logit_scale_init_value=1.0					,      from_pt=__lowerCamelCase							)
							a    =			VisionTextDualEncoderProcessor.from_pretrained("clip-italian/clip-italian"							)

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

							a    =			model(**__lowerCamelCase							)

							# 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])					,      )

							a    =			np.array([[1.2_284_727, 0.3_104_122]]							)

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












from __future__ import annotations




def 			__magic_name__				( A		:					list   ):






			'''simple docstring'''







			if len(A   ) == 0:
						return []
			a    ,		a    =			min(A   ), max(A   )
			a    =			int(max_value - min_value   ) + 1
			a    =			[[] for _ in range(A   )]

			for i in my_list:
						buckets[int(i - min_value   )].append(A   )

			return [v for bucket in buckets for v in sorted(A   )]


if __name__ == "__main__":
		from doctest import testmod

		testmod()
		assert bucket_sort([4, 5, 3, 2, 1]) == [1, 2, 3, 4, 5]
		assert bucket_sort([0, 1, -10, 15, 2, -2]) == [-10, -2, 0, 1, 2, 15]






