





'''simple docstring'''






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      __A						(							a_						:  str	):







		if isinstance(lowercase__      ,collections.abc.Iterable	):
				return x
		return (x, x)
@require_tf
class 		lowerCamelCase  :



	def   _lowerCamelCase    (   self		,      a_		,      a_	):
			pass



	def   _lowerCamelCase    (   self	):
			pass



	def   _lowerCamelCase    (   self	):
			pass



	def   _lowerCamelCase    (   self		,      a_		,      a_		,      a_		,      a_		,      a_=None		,      **a_	):
			lowerCAmelCase     :    Union[str, Any]						=   VisionTextDualEncoderConfig.from_vision_text_configs(lowerCAmelCase_		,      lowerCAmelCase_	)

			lowerCAmelCase     :    Optional[Any]						=   TFVisionTextDualEncoderModel(lowerCAmelCase_	)

			lowerCAmelCase     :    Union[str, Any]						=   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   _lowerCamelCase    (   self		,      a_		,      a_		,      a_		,      a_		,      a_=None		,      **a_	):
			lowerCAmelCase	,		lowerCAmelCase     :    Tuple						=   self.get_vision_text_model(lowerCAmelCase_		,      lowerCAmelCase_	)
			lowerCAmelCase     :    List[str]						=   TFVisionTextDualEncoderModel(vision_model=lowerCAmelCase_		,      text_model=lowerCAmelCase_	)

			lowerCAmelCase     :    Any						=   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   _lowerCamelCase    (   self		,      a_		,      a_		,      a_		,      a_		,      a_=None		,      **a_	):
			lowerCAmelCase	,		lowerCAmelCase     :    Tuple						=   self.get_vision_text_model(lowerCAmelCase_		,      lowerCAmelCase_	)
			lowerCAmelCase     :    List[Any]						=   {"vision_model": vision_model, "text_model": text_model}
			lowerCAmelCase     :    Dict						=   TFVisionTextDualEncoderModel.from_vision_text_pretrained(**lowerCAmelCase_	)

			lowerCAmelCase     :    Union[str, Any]						=   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   _lowerCamelCase    (   self		,      a_		,      a_		,      a_		,      a_		,      a_=None		,      **a_	):
			lowerCAmelCase	,		lowerCAmelCase     :    Tuple						=   self.get_vision_text_model(lowerCAmelCase_		,      lowerCAmelCase_	)
			lowerCAmelCase     :    Union[str, Any]						=   TFVisionTextDualEncoderModel(vision_model=lowerCAmelCase_		,      text_model=lowerCAmelCase_	)

			lowerCAmelCase     :    Dict						=   model(input_ids=lowerCAmelCase_		,      pixel_values=lowerCAmelCase_		,      attention_mask=lowerCAmelCase_	)
			lowerCAmelCase     :    str						=   output[0].numpy()

			with tempfile.TemporaryDirectory() as tmpdirname:
					model.save_pretrained(lowerCAmelCase_	)
					lowerCAmelCase     :    Tuple						=   TFVisionTextDualEncoderModel.from_pretrained(lowerCAmelCase_	)

					lowerCAmelCase     :    str						=   model(input_ids=lowerCAmelCase_		,      pixel_values=lowerCAmelCase_		,      attention_mask=lowerCAmelCase_	)
					lowerCAmelCase     :    str						=   after_output[0].numpy()
					lowerCAmelCase     :    Optional[int]						=   np.amax(np.abs(out_a - out_a	)	)
					self.assertLessEqual(lowerCAmelCase_		,      1e-5	)



	def   _lowerCamelCase    (   self		,      a_		,      a_		,      a_		,      a_		,      a_=None		,      **a_	):
			lowerCAmelCase	,		lowerCAmelCase     :    List[Any]						=   self.get_vision_text_model(lowerCAmelCase_		,      lowerCAmelCase_	)
			lowerCAmelCase     :    Optional[int]						=   TFVisionTextDualEncoderModel(vision_model=lowerCAmelCase_		,      text_model=lowerCAmelCase_	)

			lowerCAmelCase     :    Tuple						=   model(
			    input_ids=lowerCAmelCase_		,      pixel_values=lowerCAmelCase_		,      attention_mask=lowerCAmelCase_		,      output_attentions=lowerCAmelCase_	)

			lowerCAmelCase     :    str						=   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)
			lowerCAmelCase     :    Optional[Any]						=   to_atuple(vision_model.config.image_size	)
			lowerCAmelCase     :    Union[str, Any]						=   to_atuple(vision_model.config.patch_size	)
			lowerCAmelCase     :    Optional[int]						=   (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])
			lowerCAmelCase     :    str						=   num_patches + 1
			self.assertEqual(vision_attentions[0].shape[-3:]		,      (vision_config.num_attention_heads, seq_len, seq_len)	)

			lowerCAmelCase     :    Union[str, Any]						=   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   _lowerCamelCase    (   self		,      a_		,      a_		,      a_	):
			lowerCAmelCase     :    int						=   np.abs((a - b)	).max()
			self.assertLessEqual(lowerCAmelCase_		,      lowerCAmelCase_		,      F'''Difference between torch and flax is {diff} (>= {tol}).'''	)



	def   _lowerCamelCase    (   self	):
			lowerCAmelCase     :    Union[str, Any]						=   self.prepare_config_and_inputs()
			self.check_vision_text_dual_encoder_model(**lowerCAmelCase_	)



	def   _lowerCamelCase    (   self	):
			lowerCAmelCase     :    str						=   self.prepare_config_and_inputs()
			self.check_model_from_pretrained_configs(**lowerCAmelCase_	)



	def   _lowerCamelCase    (   self	):
			lowerCAmelCase     :    str						=   self.prepare_config_and_inputs()
			self.check_vision_text_dual_encoder_from_pretrained(**lowerCAmelCase_	)



	def   _lowerCamelCase    (   self	):
			lowerCAmelCase     :    List[Any]						=   self.prepare_config_and_inputs()
			self.check_save_load(**lowerCAmelCase_	)



	def   _lowerCamelCase    (   self	):
			lowerCAmelCase     :    Tuple						=   self.prepare_config_and_inputs()
			self.check_vision_text_output_attention(**lowerCAmelCase_	)





	@slow
	def   _lowerCamelCase    (   self	):
			lowerCAmelCase	,		lowerCAmelCase     :    Tuple						=   self.get_pretrained_model_and_inputs()

			lowerCAmelCase     :    int						=   model_a(**lowerCAmelCase_	)
			lowerCAmelCase     :    Optional[int]						=   outputs[0].numpy()

			with tempfile.TemporaryDirectory() as tmp_dirname:
					model_a.save_pretrained(lowerCAmelCase_	)
					lowerCAmelCase     :    str						=   TFVisionTextDualEncoderModel.from_pretrained(lowerCAmelCase_	)

					lowerCAmelCase     :    List[Any]						=   model_a(**lowerCAmelCase_	)
					lowerCAmelCase     :    List[Any]						=   after_outputs[0].numpy()
					lowerCAmelCase     :    Union[str, Any]						=   np.amax(np.abs(out_a - out_a	)	)
					self.assertLessEqual(lowerCAmelCase_		,      1e-5	)






@require_tf
class 		lowerCamelCase  (      __a      ,   unittest.TestCase       ):



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

			return model, inputs



	def   _lowerCamelCase    (   self		,      a_		,      a_	):
			lowerCAmelCase     :    Optional[Any]						=   TFViTModel(lowerCAmelCase_		,      name="vision_model"	)
			lowerCAmelCase     :    Tuple						=   TFBertModel(lowerCAmelCase_		,      name="text_model"	)
			return vision_model, text_model





	def   _lowerCamelCase    (   self	):
			lowerCAmelCase     :    int						=   TFViTModelTester(self	)
			lowerCAmelCase     :    Tuple						=   TFBertModelTester(self	)
			lowerCAmelCase     :    Optional[Any]						=   vit_model_tester.prepare_config_and_inputs()
			lowerCAmelCase     :    Dict						=   bert_model_tester.prepare_config_and_inputs()

			lowerCAmelCase	,		lowerCAmelCase	,		lowerCAmelCase     :    List[str]						=   vision_config_and_inputs

			(
			    (
			    lowerCAmelCase						
			)	,		(
			    lowerCAmelCase						
			)	,		(
			    lowerCAmelCase						
			)	,		(
			    lowerCAmelCase						
			)	,		(
			    lowerCAmelCase						
			)	,		(
			    lowerCAmelCase						
			)	,		(
			    lowerCAmelCase						
			)	,								
			)     :    str						=   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  (      __a      ,   unittest.TestCase       ):



	def   _lowerCamelCase    (   self	):
			lowerCAmelCase     :    Dict						=   TFVisionTextDualEncoderModel.from_vision_text_pretrained(
			    "Rocketknight1/tiny-random-deit-tf"		,      "hf-internal-testing/tiny-random-roberta"	)
			lowerCAmelCase     :    List[Any]						=   13
			lowerCAmelCase     :    Tuple						=   floats_tensor(
			    [
			        batch_size,
			        model.vision_model.config.num_channels,
			        model.vision_model.config.image_size,
			        model.vision_model.config.image_size,
			    ]	)
			lowerCAmelCase     :    Optional[Any]						=   ids_tensor([batch_size, 4]		,      model.text_model.config.vocab_size	)
			lowerCAmelCase     :    List[str]						=   random_attention_mask([batch_size, 4]	)
			lowerCAmelCase     :    Dict						=   {"pixel_values": pixel_values, "input_ids": input_ids, "attention_mask": attention_mask}

			return model, inputs



	def   _lowerCamelCase    (   self		,      a_		,      a_		,      a_		,      a_		,      a_=None		,      **a_	):
			lowerCAmelCase	,		lowerCAmelCase     :    Tuple						=   self.get_vision_text_model(lowerCAmelCase_		,      lowerCAmelCase_	)
			lowerCAmelCase     :    List[str]						=   TFVisionTextDualEncoderModel(vision_model=lowerCAmelCase_		,      text_model=lowerCAmelCase_	)

			lowerCAmelCase     :    Union[str, Any]						=   model(
			    input_ids=lowerCAmelCase_		,      pixel_values=lowerCAmelCase_		,      attention_mask=lowerCAmelCase_		,      output_attentions=lowerCAmelCase_	)

			lowerCAmelCase     :    Optional[Any]						=   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)
			lowerCAmelCase     :    Any						=   to_atuple(vision_model.config.image_size	)
			lowerCAmelCase     :    Union[str, Any]						=   to_atuple(vision_model.config.patch_size	)
			lowerCAmelCase     :    List[Any]						=   (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])
			lowerCAmelCase     :    Optional[int]						=   num_patches + 2
			self.assertEqual(vision_attentions[0].shape[-3:]		,      (vision_config.num_attention_heads, seq_len, seq_len)	)

			lowerCAmelCase     :    str						=   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   _lowerCamelCase    (   self		,      a_		,      a_	):
			lowerCAmelCase     :    int						=   TFDeiTModel(lowerCAmelCase_		,      name="vision_model"	)
			lowerCAmelCase     :    List[Any]						=   TFRobertaModel(lowerCAmelCase_		,      name="text_model"	)
			return vision_model, text_model





	def   _lowerCamelCase    (   self	):
			lowerCAmelCase     :    Tuple						=   TFDeiTModelTester(self	)
			lowerCAmelCase     :    List[Any]						=   TFRobertaModelTester(self	)
			lowerCAmelCase     :    Tuple						=   vit_model_tester.prepare_config_and_inputs()
			lowerCAmelCase     :    Any						=   bert_model_tester.prepare_config_and_inputs()

			lowerCAmelCase	,		lowerCAmelCase	,		lowerCAmelCase     :    Tuple						=   vision_config_and_inputs

			(
			    (
			    lowerCAmelCase						
			)	,		(
			    lowerCAmelCase						
			)	,		(
			    lowerCAmelCase						
			)	,		(
			    lowerCAmelCase						
			)	,		(
			    lowerCAmelCase						
			)	,		(
			    lowerCAmelCase						
			)	,		(
			    lowerCAmelCase						
			)	,								
			)     :    Optional[Any]						=   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  (      __a      ,   unittest.TestCase       ):



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

			return model, inputs



	def   _lowerCamelCase    (   self		,      a_		,      a_	):
			lowerCAmelCase     :    Optional[int]						=   TFCLIPVisionModel(lowerCAmelCase_		,      name="vision_model"	)
			lowerCAmelCase     :    Tuple						=   TFBertModel(lowerCAmelCase_		,      name="text_model"	)
			return vision_model, text_model





	def   _lowerCamelCase    (   self	):
			lowerCAmelCase     :    List[Any]						=   TFCLIPVisionModelTester(self	)
			lowerCAmelCase     :    Any						=   TFBertModelTester(self	)
			lowerCAmelCase     :    Optional[Any]						=   clip_model_tester.prepare_config_and_inputs()
			lowerCAmelCase     :    str						=   bert_model_tester.prepare_config_and_inputs()

			lowerCAmelCase	,		lowerCAmelCase     :    Union[str, Any]						=   vision_config_and_inputs

			(
			    (
			    lowerCAmelCase						
			)	,		(
			    lowerCAmelCase						
			)	,		(
			    lowerCAmelCase						
			)	,		(
			    lowerCAmelCase						
			)	,		(
			    lowerCAmelCase						
			)	,		(
			    lowerCAmelCase						
			)	,		(
			    lowerCAmelCase						
			)	,								
			)     :    Dict						=   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       ):



	@slow
	def   _lowerCamelCase    (   self	):
			lowerCAmelCase     :    List[Any]						=   TFVisionTextDualEncoderModel.from_pretrained(
			    "clip-italian/clip-italian"		,      logit_scale_init_value=1.0		,      from_pt=lowerCAmelCase_	)
			lowerCAmelCase     :    Optional[int]						=   VisionTextDualEncoderProcessor.from_pretrained("clip-italian/clip-italian"	)

			lowerCAmelCase     :    int						=   Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"	)
			lowerCAmelCase     :    Union[str, Any]						=   processor(
			    text=["una foto di un gatto", "una foto di un cane"]		,      images=lowerCAmelCase_		,      padding=lowerCAmelCase_		,      return_tensors="np"	)

			lowerCAmelCase     :    int						=   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])		,      )

			lowerCAmelCase     :    Union[str, Any]						=   np.array([[1.2284727, 0.3104122]]	)

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










'''simple docstring'''






def      __A						(							a_						:  int	):
		if not isinstance(a_      ,a_	):
				lowerCAmelCase     :    Dict						=   f'''Input value of [number={number}] must be an integer'''
				raise TypeError(a_	)
		if number < 0:
				return False
		lowerCAmelCase     :    Dict						=   number * number
		while number > 0:
				if number % 1_0 != number_square % 1_0:
						return False
				number //= 1_0
				number_square //= 1_0
		return True


if __name__ == "__main__":
					import doctest

					doctest.testmod()



