




"""simple docstring"""


from typing import Dict, Iterable, Optional, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import normalize, rescale, resize, to_channel_dimension_format, to_pil_image
from ...image_utils import (
    IMAGENET_STANDARD_MEAN,
    IMAGENET_STANDARD_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_pytesseract_available, is_vision_available, logging, requires_backends


if is_vision_available():
  import PIL

# soft dependency
if is_pytesseract_available():
  import pytesseract

_A													=      logging.get_logger(__name__)



def 	lowercase_				(			__UpperCAmelCase    ,		__UpperCAmelCase    ,		__UpperCAmelCase				)						->    Union[str, Any]:
      return [
          int(1000 * (box[0] / width)				),
          int(1000 * (box[1] / height)				),
          int(1000 * (box[2] / width)				),
          int(1000 * (box[3] / height)				),
      ]



def 	lowercase_				(			__UpperCAmelCase    ,		__UpperCAmelCase    ,		__UpperCAmelCase				)						->    Any:
      lowerCAmelCase__      :			List[str]   =	to_pil_image(__UpperCAmelCase				)
      lowerCAmelCase__ ,   lowerCAmelCase__      :			Union[str, Any]   =	pil_image.size
      lowerCAmelCase__      :			Dict   =	pytesseract.image_to_data(__UpperCAmelCase    ,		lang=__UpperCAmelCase    ,		output_type="""dict"""    ,		config=__UpperCAmelCase				)
      lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__      :			List[Any]   =	data["""text"""], data["""left"""], data["""top"""], data["""width"""], data["""height"""]

      # filter empty words and corresponding coordinates
      lowerCAmelCase__      :			str   =	[idx for idx, word in enumerate(__UpperCAmelCase				) if not word.strip()]
      lowerCAmelCase__      :			Optional[int]   =	[word for idx, word in enumerate(__UpperCAmelCase				) if idx not in irrelevant_indices]
      lowerCAmelCase__      :			Optional[Any]   =	[coord for idx, coord in enumerate(__UpperCAmelCase				) if idx not in irrelevant_indices]
      lowerCAmelCase__      :			Any   =	[coord for idx, coord in enumerate(__UpperCAmelCase				) if idx not in irrelevant_indices]
      lowerCAmelCase__      :			List[Any]   =	[coord for idx, coord in enumerate(__UpperCAmelCase				) if idx not in irrelevant_indices]
      lowerCAmelCase__      :			int   =	[coord for idx, coord in enumerate(__UpperCAmelCase				) if idx not in irrelevant_indices]

      # turn coordinates into (left, top, left+width, top+height) format
      lowerCAmelCase__      :			Optional[int]   =	[]
      for x, y, w, h in zip(__UpperCAmelCase    ,		__UpperCAmelCase    ,		__UpperCAmelCase    ,		__UpperCAmelCase				):
            lowerCAmelCase__      :			Dict   =	[x, y, x + w, y + h]
            actual_boxes.append(__UpperCAmelCase				)

      # finally, normalize the bounding boxes
      lowerCAmelCase__      :			List[Any]   =	[]
      for box in actual_boxes:
            normalized_boxes.append(normalize_box(__UpperCAmelCase    ,		__UpperCAmelCase    ,		__UpperCAmelCase				)				)

      assert len(__UpperCAmelCase				) == len(__UpperCAmelCase				), "Not as many words as there are bounding boxes"

      return words, normalized_boxes


class _lowerCamelCase    (					a_						):
   _lowerCamelCase    :Union[str, Any]     				=     ["pixel_values"]






   def __init__(		self       :		Optional[int]   ,     UpperCamelCase       :		bool = True   ,     UpperCamelCase       :		Dict[str, int] = None   ,     UpperCamelCase       :		PILImageResampling = PILImageResampling.BILINEAR   ,     UpperCamelCase       :		bool = True   ,     UpperCamelCase       :		float = 1 / 2_55   ,     UpperCamelCase       :		bool = True   ,     UpperCamelCase       :		Union[float, Iterable[float]] = None   ,     UpperCamelCase       :		Union[float, Iterable[float]] = None   ,     UpperCamelCase       :		bool = True   ,     UpperCamelCase       :		Optional[str] = None   ,     UpperCamelCase       :		Optional[str] = ""   ,     **UpperCamelCase       :		str   ,     )			->						None:

         """simple docstring"""
         super().__init__(**UpperCamelCase   )
         lowerCAmelCase__      :			List[Any]   =	size if size is not None else {"""height""": 2_24, """width""": 2_24}
         lowerCAmelCase__      :			Union[str, Any]   =	get_size_dict(UpperCamelCase   )

         lowerCAmelCase__      :			int   =	do_resize
         lowerCAmelCase__      :			Union[str, Any]   =	size
         lowerCAmelCase__      :			Union[str, Any]   =	resample
         lowerCAmelCase__      :			Optional[int]   =	do_rescale
         lowerCAmelCase__      :			Optional[int]   =	rescale_value
         lowerCAmelCase__      :			Dict   =	do_normalize
         lowerCAmelCase__      :			Optional[int]   =	image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
         lowerCAmelCase__      :			Dict   =	image_std if image_std is not None else IMAGENET_STANDARD_STD
         lowerCAmelCase__      :			Optional[int]   =	apply_ocr
         lowerCAmelCase__      :			List[Any]   =	ocr_lang
         lowerCAmelCase__      :			int   =	tesseract_config






   def 	_lowerCAmelCase   (		self       :		str   ,     UpperCamelCase       :		np.ndarray   ,     UpperCamelCase       :		Dict[str, int]   ,     UpperCamelCase       :		PILImageResampling = PILImageResampling.BILINEAR   ,     UpperCamelCase       :		Optional[Union[str, ChannelDimension]] = None   ,     **UpperCamelCase       :		str   ,     )			->						np.ndarray:

         """simple docstring"""
         lowerCAmelCase__      :			List[Any]   =	get_size_dict(UpperCamelCase   )
         if "height" not in size or "width" not in size:
               raise ValueError(f"""The size dictionary must contain the keys 'height' and 'width'. Got {size.keys()}"""   )
         lowerCAmelCase__      :			Optional[int]   =	(size["""height"""], size["""width"""])
         return resize(UpperCamelCase   ,     size=UpperCamelCase   ,     resample=UpperCamelCase   ,     data_format=UpperCamelCase   ,     **UpperCamelCase   )






   def 	_lowerCAmelCase   (		self       :		str   ,     UpperCamelCase       :		np.ndarray   ,     UpperCamelCase       :		Union[int, float]   ,     UpperCamelCase       :		Optional[Union[str, ChannelDimension]] = None   ,     **UpperCamelCase       :		Tuple   ,     )			->						np.ndarray:

         """simple docstring"""
         return rescale(UpperCamelCase   ,     scale=UpperCamelCase   ,     data_format=UpperCamelCase   ,     **UpperCamelCase   )






   def 	_lowerCAmelCase   (		self       :		List[Any]   ,     UpperCamelCase       :		np.ndarray   ,     UpperCamelCase       :		Union[float, Iterable[float]]   ,     UpperCamelCase       :		Union[float, Iterable[float]]   ,     UpperCamelCase       :		Optional[Union[str, ChannelDimension]] = None   ,     **UpperCamelCase       :		Optional[int]   ,     )			->						np.ndarray:

         """simple docstring"""
         return normalize(UpperCamelCase   ,     mean=UpperCamelCase   ,     std=UpperCamelCase   ,     data_format=UpperCamelCase   ,     **UpperCamelCase   )






   def 	_lowerCAmelCase   (		self       :		Tuple   ,     UpperCamelCase       :		ImageInput   ,     UpperCamelCase       :		bool = None   ,     UpperCamelCase       :		Dict[str, int] = None   ,     UpperCamelCase       :		List[str]=None   ,     UpperCamelCase       :		bool = None   ,     UpperCamelCase       :		float = None   ,     UpperCamelCase       :		bool = None   ,     UpperCamelCase       :		Union[float, Iterable[float]] = None   ,     UpperCamelCase       :		Union[float, Iterable[float]] = None   ,     UpperCamelCase       :		bool = None   ,     UpperCamelCase       :		Optional[str] = None   ,     UpperCamelCase       :		Optional[str] = None   ,     UpperCamelCase       :		Optional[Union[str, TensorType]] = None   ,     UpperCamelCase       :		ChannelDimension = ChannelDimension.FIRST   ,     **UpperCamelCase       :		Any   ,     )			->						PIL.Image.Image:

         """simple docstring"""
         lowerCAmelCase__      :			Tuple   =	do_resize if do_resize is not None else self.do_resize
         lowerCAmelCase__      :			Optional[int]   =	size if size is not None else self.size
         lowerCAmelCase__      :			Optional[Any]   =	get_size_dict(UpperCamelCase   )
         lowerCAmelCase__      :			List[Any]   =	resample if resample is not None else self.resample
         lowerCAmelCase__      :			Tuple   =	do_rescale if do_rescale is not None else self.do_rescale
         lowerCAmelCase__      :			Optional[int]   =	rescale_factor if rescale_factor is not None else self.rescale_factor
         lowerCAmelCase__      :			int   =	do_normalize if do_normalize is not None else self.do_normalize
         lowerCAmelCase__      :			Tuple   =	image_mean if image_mean is not None else self.image_mean
         lowerCAmelCase__      :			Tuple   =	image_std if image_std is not None else self.image_std
         lowerCAmelCase__      :			int   =	apply_ocr if apply_ocr is not None else self.apply_ocr
         lowerCAmelCase__      :			Any   =	ocr_lang if ocr_lang is not None else self.ocr_lang
         lowerCAmelCase__      :			Optional[Any]   =	tesseract_config if tesseract_config is not None else self.tesseract_config

         lowerCAmelCase__      :			str   =	make_list_of_images(UpperCamelCase   )

         if not valid_images(UpperCamelCase   ):
               raise ValueError(
                   """Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, """
                   """torch.Tensor, tf.Tensor or jax.ndarray."""   )

         if do_resize and size is None:
               raise ValueError("""Size must be specified if do_resize is True."""   )

         if do_rescale and rescale_factor is None:
               raise ValueError("""Rescale factor must be specified if do_rescale is True."""   )

         if do_normalize and (image_mean is None or image_std is None):
               raise ValueError("""If do_normalize is True, image_mean and image_std must be specified."""   )

         # All transformations expect numpy arrays.
         lowerCAmelCase__      :			Any   =	[to_numpy_array(UpperCamelCase   ) for image in images]

         # Tesseract OCR to get words + normalized bounding boxes
         if apply_ocr:
               requires_backends(self   ,     """pytesseract"""   )
               lowerCAmelCase__      :			Optional[int]   =	[]
               lowerCAmelCase__      :			Any   =	[]
               for image in images:
                     lowerCAmelCase__ ,   lowerCAmelCase__      :			str   =	apply_tesseract(UpperCamelCase   ,     UpperCamelCase   ,     UpperCamelCase   )
                     words_batch.append(UpperCamelCase   )
                     boxes_batch.append(UpperCamelCase   )

         if do_resize:
               lowerCAmelCase__      :			Any   =	[self.resize(image=UpperCamelCase   ,     size=UpperCamelCase   ,     resample=UpperCamelCase   ) for image in images]

         if do_rescale:
               lowerCAmelCase__      :			Union[str, Any]   =	[self.rescale(image=UpperCamelCase   ,     scale=UpperCamelCase   ) for image in images]

         if do_normalize:
               lowerCAmelCase__      :			Tuple   =	[self.normalize(image=UpperCamelCase   ,     mean=UpperCamelCase   ,     std=UpperCamelCase   ) for image in images]

         lowerCAmelCase__      :			Optional[int]   =	[to_channel_dimension_format(UpperCamelCase   ,     UpperCamelCase   ) for image in images]

         lowerCAmelCase__      :			int   =	BatchFeature(data={"""pixel_values""": images}   ,     tensor_type=UpperCamelCase   )

         if apply_ocr:
               lowerCAmelCase__      :			List[Any]   =	words_batch
               lowerCAmelCase__      :			List[str]   =	boxes_batch
         return data











"""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 	lowercase_				(			__UpperCAmelCase				)						->    str:
      if isinstance(__UpperCAmelCase    ,		collections.abc.Iterable				):
            return x
      return (x, x)


@require_tf
class _lowerCamelCase    :






   def 	_lowerCAmelCase   (		self       :		Dict   ,     UpperCamelCase       :		List[Any]   ,     UpperCamelCase       :		int   )			->						int:

         """simple docstring"""
         pass






   def 	_lowerCAmelCase   (		self       :		Optional[Any]   )			->						Optional[Any]:

         """simple docstring"""
         pass






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

         """simple docstring"""
         pass






   def 	_lowerCAmelCase   (		self       :		str   ,     UpperCamelCase       :		Tuple   ,     UpperCamelCase       :		Optional[Any]   ,     UpperCamelCase       :		List[Any]   ,     UpperCamelCase       :		Dict   ,     UpperCamelCase       :		Any=None   ,     **UpperCamelCase       :		Optional[Any]   )			->						str:

         """simple docstring"""
         lowerCAmelCase__      :			Optional[int]   =	VisionTextDualEncoderConfig.from_vision_text_configs(UpperCamelCase   ,     UpperCamelCase   )

         lowerCAmelCase__      :			Dict   =	TFVisionTextDualEncoderModel(UpperCamelCase   )

         lowerCAmelCase__      :			List[Any]   =	model(input_ids=UpperCamelCase   ,     pixel_values=UpperCamelCase   ,     attention_mask=UpperCamelCase   )

         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       :		int   ,     UpperCamelCase       :		List[str]   ,     UpperCamelCase       :		Union[str, Any]   ,     UpperCamelCase       :		Tuple   ,     UpperCamelCase       :		Dict   ,     UpperCamelCase       :		Any=None   ,     **UpperCamelCase       :		Union[str, Any]   )			->						Dict:

         """simple docstring"""
         lowerCAmelCase__ ,   lowerCAmelCase__      :			Optional[int]   =	self.get_vision_text_model(UpperCamelCase   ,     UpperCamelCase   )
         lowerCAmelCase__      :			Union[str, Any]   =	TFVisionTextDualEncoderModel(vision_model=UpperCamelCase   ,     text_model=UpperCamelCase   )

         lowerCAmelCase__      :			Optional[int]   =	model(input_ids=UpperCamelCase   ,     pixel_values=UpperCamelCase   ,     attention_mask=UpperCamelCase   )

         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]   ,     UpperCamelCase       :		Any   ,     UpperCamelCase       :		str   ,     UpperCamelCase       :		Tuple   ,     UpperCamelCase       :		Union[str, Any]   ,     UpperCamelCase       :		List[str]=None   ,     **UpperCamelCase       :		Optional[Any]   )			->						Any:

         """simple docstring"""
         lowerCAmelCase__ ,   lowerCAmelCase__      :			int   =	self.get_vision_text_model(UpperCamelCase   ,     UpperCamelCase   )
         lowerCAmelCase__      :			Dict   =	{"""vision_model""": vision_model, """text_model""": text_model}
         lowerCAmelCase__      :			Optional[int]   =	TFVisionTextDualEncoderModel.from_vision_text_pretrained(**UpperCamelCase   )

         lowerCAmelCase__      :			Union[str, Any]   =	model(input_ids=UpperCamelCase   ,     pixel_values=UpperCamelCase   ,     attention_mask=UpperCamelCase   )

         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       :		int   ,     UpperCamelCase       :		List[str]   ,     UpperCamelCase       :		Optional[Any]   ,     UpperCamelCase       :		Any   ,     UpperCamelCase       :		List[str]   ,     UpperCamelCase       :		Tuple=None   ,     **UpperCamelCase       :		Optional[Any]   )			->						Any:

         """simple docstring"""
         lowerCAmelCase__ ,   lowerCAmelCase__      :			Optional[int]   =	self.get_vision_text_model(UpperCamelCase   ,     UpperCamelCase   )
         lowerCAmelCase__      :			Optional[Any]   =	TFVisionTextDualEncoderModel(vision_model=UpperCamelCase   ,     text_model=UpperCamelCase   )

         lowerCAmelCase__      :			List[Any]   =	model(input_ids=UpperCamelCase   ,     pixel_values=UpperCamelCase   ,     attention_mask=UpperCamelCase   )
         lowerCAmelCase__      :			Union[str, Any]   =	output[0].numpy()

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

               lowerCAmelCase__      :			Optional[Any]   =	model(input_ids=UpperCamelCase   ,     pixel_values=UpperCamelCase   ,     attention_mask=UpperCamelCase   )
               lowerCAmelCase__      :			int   =	after_output[0].numpy()
               lowerCAmelCase__      :			Tuple   =	np.amax(np.abs(out_a - out_a   )   )
               self.assertLessEqual(UpperCamelCase   ,     1E-5   )






   def 	_lowerCAmelCase   (		self       :		int   ,     UpperCamelCase       :		Dict   ,     UpperCamelCase       :		str   ,     UpperCamelCase       :		Optional[int]   ,     UpperCamelCase       :		List[str]   ,     UpperCamelCase       :		List[Any]=None   ,     **UpperCamelCase       :		Optional[int]   )			->						Dict:

         """simple docstring"""
         lowerCAmelCase__ ,   lowerCAmelCase__      :			str   =	self.get_vision_text_model(UpperCamelCase   ,     UpperCamelCase   )
         lowerCAmelCase__      :			int   =	TFVisionTextDualEncoderModel(vision_model=UpperCamelCase   ,     text_model=UpperCamelCase   )

         lowerCAmelCase__      :			Dict   =	model(
             input_ids=UpperCamelCase   ,     pixel_values=UpperCamelCase   ,     attention_mask=UpperCamelCase   ,     output_attentions=UpperCamelCase   )

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

         lowerCAmelCase__      :			List[str]   =	output.text_model_output.attentions
         self.assertEqual(len(UpperCamelCase   )   ,     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       :		Union[str, Any]   ,     UpperCamelCase       :		np.ndarray   ,     UpperCamelCase       :		np.ndarray   ,     UpperCamelCase       :		float   )			->						Optional[Any]:

         """simple docstring"""
         lowerCAmelCase__      :			List[str]   =	np.abs((a - b)   ).max()
         self.assertLessEqual(UpperCamelCase   ,     UpperCamelCase   ,     f"""Difference between torch and flax is {diff} (>= {tol})."""   )






   def 	_lowerCAmelCase   (		self       :		str   )			->						Dict:

         """simple docstring"""
         lowerCAmelCase__      :			Union[str, Any]   =	self.prepare_config_and_inputs()
         self.check_vision_text_dual_encoder_model(**UpperCamelCase   )






   def 	_lowerCAmelCase   (		self       :		Dict   )			->						int:

         """simple docstring"""
         lowerCAmelCase__      :			Any   =	self.prepare_config_and_inputs()
         self.check_model_from_pretrained_configs(**UpperCamelCase   )






   def 	_lowerCAmelCase   (		self       :		Optional[Any]   )			->						Tuple:

         """simple docstring"""
         lowerCAmelCase__      :			Optional[int]   =	self.prepare_config_and_inputs()
         self.check_vision_text_dual_encoder_from_pretrained(**UpperCamelCase   )






   def 	_lowerCAmelCase   (		self       :		Any   )			->						str:

         """simple docstring"""
         lowerCAmelCase__      :			Optional[Any]   =	self.prepare_config_and_inputs()
         self.check_save_load(**UpperCamelCase   )






   def 	_lowerCAmelCase   (		self       :		Optional[int]   )			->						Optional[Any]:

         """simple docstring"""
         lowerCAmelCase__      :			Optional[int]   =	self.prepare_config_and_inputs()
         self.check_vision_text_output_attention(**UpperCamelCase   )






   @slow
   def 	_lowerCAmelCase   (		self       :		str   )			->						List[str]:

         """simple docstring"""
         lowerCAmelCase__ ,   lowerCAmelCase__      :			List[str]   =	self.get_pretrained_model_and_inputs()

         lowerCAmelCase__      :			Union[str, Any]   =	model_a(**UpperCamelCase   )
         lowerCAmelCase__      :			Any   =	outputs[0].numpy()

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

               lowerCAmelCase__      :			List[str]   =	model_a(**UpperCamelCase   )
               lowerCAmelCase__      :			Dict   =	after_outputs[0].numpy()
               lowerCAmelCase__      :			List[str]   =	np.amax(np.abs(out_a - out_a   )   )
               self.assertLessEqual(UpperCamelCase   ,     1E-5   )






@require_tf
class _lowerCamelCase    (					a_       ,	unittest.TestCase						):






   def 	_lowerCAmelCase   (		self       :		int   )			->						Dict:

         """simple docstring"""
         lowerCAmelCase__      :			Dict   =	TFVisionTextDualEncoderModel.from_vision_text_pretrained(
             """hf-internal-testing/tiny-random-vit"""   ,     """hf-internal-testing/tiny-random-bert"""   )
         lowerCAmelCase__      :			Optional[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__      :			Dict   =	ids_tensor([batch_size, 4]   ,     model.text_model.config.vocab_size   )
         lowerCAmelCase__      :			Optional[Any]   =	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       :		Any   ,     UpperCamelCase       :		Union[str, Any]   ,     UpperCamelCase       :		int   )			->						str:

         """simple docstring"""
         lowerCAmelCase__      :			str   =	TFViTModel(UpperCamelCase   ,     name="""vision_model"""   )
         lowerCAmelCase__      :			Any   =	TFBertModel(UpperCamelCase   ,     name="""text_model"""   )
         return vision_model, text_model






   def 	_lowerCAmelCase   (		self       :		int   )			->						Dict:

         """simple docstring"""
         lowerCAmelCase__      :			str   =	TFViTModelTester(self   )
         lowerCAmelCase__      :			str   =	TFBertModelTester(self   )
         lowerCAmelCase__      :			Optional[int]   =	vit_model_tester.prepare_config_and_inputs()
         lowerCAmelCase__      :			List[Any]   =	bert_model_tester.prepare_config_and_inputs()

         lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__      :			Dict   =	vision_config_and_inputs

         (
             (
             lowerCAmelCase__
         ) ,   (
             lowerCAmelCase__
         ) ,   (
             lowerCAmelCase__
         ) ,   (
             lowerCAmelCase__
         ) ,   (
             lowerCAmelCase__
         ) ,   (
             lowerCAmelCase__
         ) ,   (
             lowerCAmelCase__
         ) ,   
         )      :			List[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       :		int   )			->						str:

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

         return model, inputs






   def 	_lowerCAmelCase   (		self       :		Optional[Any]   ,     UpperCamelCase       :		Union[str, Any]   ,     UpperCamelCase       :		Union[str, Any]   ,     UpperCamelCase       :		Optional[Any]   ,     UpperCamelCase       :		str   ,     UpperCamelCase       :		str=None   ,     **UpperCamelCase       :		Optional[Any]   )			->						int:

         """simple docstring"""
         lowerCAmelCase__ ,   lowerCAmelCase__      :			List[Any]   =	self.get_vision_text_model(UpperCamelCase   ,     UpperCamelCase   )
         lowerCAmelCase__      :			Optional[Any]   =	TFVisionTextDualEncoderModel(vision_model=UpperCamelCase   ,     text_model=UpperCamelCase   )

         lowerCAmelCase__      :			Optional[Any]   =	model(
             input_ids=UpperCamelCase   ,     pixel_values=UpperCamelCase   ,     attention_mask=UpperCamelCase   ,     output_attentions=UpperCamelCase   )

         lowerCAmelCase__      :			Optional[int]   =	output.vision_model_output.attentions
         self.assertEqual(len(UpperCamelCase   )   ,     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__      :			Dict   =	to_atuple(vision_model.config.image_size   )
         lowerCAmelCase__      :			Any   =	to_atuple(vision_model.config.patch_size   )
         lowerCAmelCase__      :			Dict   =	(image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])
         lowerCAmelCase__      :			Optional[Any]   =	num_patches + 2
         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(UpperCamelCase   )   ,     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       :		int   ,     UpperCamelCase       :		Any   ,     UpperCamelCase       :		str   )			->						List[Any]:

         """simple docstring"""
         lowerCAmelCase__      :			Any   =	TFDeiTModel(UpperCamelCase   ,     name="""vision_model"""   )
         lowerCAmelCase__      :			str   =	TFRobertaModel(UpperCamelCase   ,     name="""text_model"""   )
         return vision_model, text_model






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

         """simple docstring"""
         lowerCAmelCase__      :			Optional[Any]   =	TFDeiTModelTester(self   )
         lowerCAmelCase__      :			Union[str, Any]   =	TFRobertaModelTester(self   )
         lowerCAmelCase__      :			Optional[int]   =	vit_model_tester.prepare_config_and_inputs()
         lowerCAmelCase__      :			Any   =	bert_model_tester.prepare_config_and_inputs()

         lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__      :			Optional[Any]   =	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       :		List[str]   )			->						Tuple:

         """simple docstring"""
         lowerCAmelCase__      :			Union[str, Any]   =	TFVisionTextDualEncoderModel.from_vision_text_pretrained(
             """Rocketknight1/tiny-random-clip-tf"""   ,     """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__      :			Optional[Any]   =	ids_tensor([batch_size, 4]   ,     model.text_model.config.vocab_size   )
         lowerCAmelCase__      :			str   =	random_attention_mask([batch_size, 4]   )
         lowerCAmelCase__      :			List[str]   =	{"""pixel_values""": pixel_values, """input_ids""": input_ids, """attention_mask""": attention_mask}

         return model, inputs






   def 	_lowerCAmelCase   (		self       :		str   ,     UpperCamelCase       :		str   ,     UpperCamelCase       :		Optional[Any]   )			->						Any:

         """simple docstring"""
         lowerCAmelCase__      :			int   =	TFCLIPVisionModel(UpperCamelCase   ,     name="""vision_model"""   )
         lowerCAmelCase__      :			List[str]   =	TFBertModel(UpperCamelCase   ,     name="""text_model"""   )
         return vision_model, text_model






   def 	_lowerCAmelCase   (		self       :		Optional[Any]   )			->						Optional[int]:

         """simple docstring"""
         lowerCAmelCase__      :			str   =	TFCLIPVisionModelTester(self   )
         lowerCAmelCase__      :			int   =	TFBertModelTester(self   )
         lowerCAmelCase__      :			str   =	clip_model_tester.prepare_config_and_inputs()
         lowerCAmelCase__      :			Optional[int]   =	bert_model_tester.prepare_config_and_inputs()

         lowerCAmelCase__ ,   lowerCAmelCase__      :			Dict   =	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_vision
@require_tf
class _lowerCamelCase    (					unittest.TestCase						):






   @slow
   def 	_lowerCAmelCase   (		self       :		Optional[int]   )			->						Optional[int]:

         """simple docstring"""
         lowerCAmelCase__      :			List[str]   =	TFVisionTextDualEncoderModel.from_pretrained(
             """clip-italian/clip-italian"""   ,     logit_scale_init_value=1.0   ,     from_pt=UpperCamelCase   )
         lowerCAmelCase__      :			Any   =	VisionTextDualEncoderProcessor.from_pretrained("""clip-italian/clip-italian"""   )

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

         lowerCAmelCase__      :			Tuple   =	model(**UpperCamelCase   )

         # 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__      :			List[Any]   =	np.array([[1.228_4727, 0.310_4122]]   )

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





