


from __future__ import annotations

import copy
import inspect
import json
import math
import os
import tempfile
import unittest
from importlib import import_module

import numpy as np

from transformers import ViTMAEConfig
from transformers.file_utils import cached_property, is_tf_available, is_vision_available
from transformers.testing_utils import require_tf, require_vision, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
 import tensorflow as tf

 from transformers import TFViTMAEForPreTraining, TFViTMAEModel


if is_vision_available():
 from PIL import Image

 from transformers import ViTImageProcessor






class   __lowercase				:





      def __init__(		self						:					int					,       __lowerCamelCase						:					Any					,       __lowerCamelCase						:					Any=1_3					,       __lowerCamelCase						:					Any=3_0					,       __lowerCamelCase						:					List[str]=2					,       __lowerCamelCase						:					str=3					,       __lowerCamelCase						:					Optional[int]=True					,       __lowerCamelCase						:					Any=True					,       __lowerCamelCase						:					Optional[int]=3_2					,       __lowerCamelCase						:					Union[str, Any]=2					,       __lowerCamelCase						:					List[str]=4					,       __lowerCamelCase						:					List[Any]=3_7					,       __lowerCamelCase						:					Dict="gelu"					,       __lowerCamelCase						:					Tuple=0.1					,       __lowerCamelCase						:					Dict=0.1					,       __lowerCamelCase						:					int=1_0					,       __lowerCamelCase						:					Optional[int]=0.02					,       __lowerCamelCase						:					Tuple=3					,       __lowerCamelCase						:					int=0.6					,       __lowerCamelCase						:					str=None					,       )    ->   List[str]:






         """simple docstring"""







         UpperCAmelCase							=     parent
         UpperCAmelCase							=     batch_size
         UpperCAmelCase							=     image_size
         UpperCAmelCase							=     patch_size
         UpperCAmelCase							=     num_channels
         UpperCAmelCase							=     is_training
         UpperCAmelCase							=     use_labels
         UpperCAmelCase							=     hidden_size
         UpperCAmelCase							=     num_hidden_layers
         UpperCAmelCase							=     num_attention_heads
         UpperCAmelCase							=     intermediate_size
         UpperCAmelCase							=     hidden_act
         UpperCAmelCase							=     hidden_dropout_prob
         UpperCAmelCase							=     attention_probs_dropout_prob
         UpperCAmelCase							=     type_sequence_label_size
         UpperCAmelCase							=     initializer_range
         UpperCAmelCase							=     mask_ratio
         UpperCAmelCase							=     scope

         # in ViTMAE, the expected sequence length = (num_patches + 1) * (1 - config.mask_ratio), rounded above
         # (we add 1 for the [CLS] token)
         UpperCAmelCase							=     (image_size // patch_size) ** 2
         UpperCAmelCase							=     int(math.ceil((1 - mask_ratio) * (num_patches + 1)       )       )





      def        _lowercase				(		self						:					List[str]       )    ->   List[Any]:






         """simple docstring"""







         UpperCAmelCase							=     floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]       )

         UpperCAmelCase							=     None
         if self.use_labels:
            UpperCAmelCase							=     ids_tensor([self.batch_size]					,       self.type_sequence_label_size       )

         UpperCAmelCase							=     self.get_config()

         return config, pixel_values, labels





      def        _lowercase				(		self						:					List[str]       )    ->   List[Any]:






         """simple docstring"""







         return ViTMAEConfig(
             image_size=self.image_size					,       patch_size=self.patch_size					,       num_channels=self.num_channels					,       hidden_size=self.hidden_size					,       num_hidden_layers=self.num_hidden_layers					,       num_attention_heads=self.num_attention_heads					,       intermediate_size=self.intermediate_size					,       decoder_hidden_size=self.hidden_size					,       decoder_num_hidden_layers=self.num_hidden_layers					,       decoder_num_attention_heads=self.num_attention_heads					,       decoder_intermediate_size=self.intermediate_size					,       hidden_act=self.hidden_act					,       hidden_dropout_prob=self.hidden_dropout_prob					,       attention_probs_dropout_prob=self.attention_probs_dropout_prob					,       is_decoder=A__					,       initializer_range=self.initializer_range					,       mask_ratio=self.mask_ratio					,       )





      def        _lowercase				(		self						:					Tuple					,       __lowerCamelCase						:					Tuple					,       __lowerCamelCase						:					Any					,       __lowerCamelCase						:					Dict       )    ->   Tuple:






         """simple docstring"""







         UpperCAmelCase							=     TFViTMAEModel(config=A__       )
         UpperCAmelCase							=     model(A__					,       training=A__       )
         self.parent.assertEqual(result.last_hidden_state.shape					,       (self.batch_size, self.seq_length, self.hidden_size)       )





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






         """simple docstring"""







         UpperCAmelCase							=     TFViTMAEForPreTraining(A__       )
         UpperCAmelCase							=     model(A__					,       training=A__       )
         # expected sequence length = num_patches
         UpperCAmelCase							=     (self.image_size // self.patch_size) ** 2
         UpperCAmelCase							=     self.patch_size**2 * self.num_channels
         self.parent.assertEqual(result.logits.shape					,       (self.batch_size, num_patches, expected_num_channels)       )

         # test greyscale images
         UpperCAmelCase							=     1
         UpperCAmelCase							=     TFViTMAEForPreTraining(A__       )

         UpperCAmelCase							=     floats_tensor([self.batch_size, 1, self.image_size, self.image_size]       )
         UpperCAmelCase							=     model(A__					,       training=A__       )
         UpperCAmelCase							=     self.patch_size**2
         self.parent.assertEqual(result.logits.shape					,       (self.batch_size, num_patches, expected_num_channels)       )





      def        _lowercase				(		self						:					int       )    ->   Tuple:






         """simple docstring"""







         UpperCAmelCase							=     self.prepare_config_and_inputs()
         ((UpperCAmelCase)				,  (UpperCAmelCase)				,  (UpperCAmelCase))							=     config_and_inputs
         UpperCAmelCase							=     {"""pixel_values""": pixel_values}
         return config, inputs_dict






@require_tf
class   __lowercase				(  _lowerCamelCase ,					_lowerCamelCase ,					unittest.TestCase  ):
      UpperCamelCase								=       (TFViTMAEModel, TFViTMAEForPreTraining) if is_tf_available() else ()
      UpperCamelCase								=       {'''feature-extraction''': TFViTMAEModel} if is_tf_available() else {}

      UpperCamelCase								=       False
      UpperCamelCase								=       False
      UpperCamelCase								=       False
      UpperCamelCase								=       False





      def        _lowercase				(		self						:					Optional[int]       )    ->   int:






         """simple docstring"""







         UpperCAmelCase							=     TFViTMAEModelTester(self       )
         UpperCAmelCase							=     ConfigTester(self					,       config_class=A__					,       has_text_modality=A__					,       hidden_size=3_7       )





      def        _lowercase				(		self						:					List[str]       )    ->   Optional[int]:






         """simple docstring"""







         self.config_tester.run_common_tests()





      @unittest.skip(reason="""ViTMAE does not use inputs_embeds"""       )
      def        _lowercase				(		self						:					List[str]       )    ->   List[Any]:






         """simple docstring"""







         pass





      def        _lowercase				(		self						:					int       )    ->   Tuple:






         """simple docstring"""







         UpperCAmelCase				,  UpperCAmelCase							=     self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
            UpperCAmelCase							=     model_class(A__       )
            self.assertIsInstance(model.get_input_embeddings()					,       (tf.keras.layers.Layer)       )
            UpperCAmelCase							=     model.get_output_embeddings()
            self.assertTrue(x is None or isinstance(A__					,       tf.keras.layers.Layer       )       )





      def        _lowercase				(		self						:					Union[str, Any]       )    ->   Tuple:






         """simple docstring"""







         UpperCAmelCase				,  UpperCAmelCase							=     self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
            UpperCAmelCase							=     model_class(A__       )
            UpperCAmelCase							=     inspect.signature(model.call       )
            # signature.parameters is an OrderedDict => so arg_names order is deterministic
            UpperCAmelCase							=     [*signature.parameters.keys()]

            UpperCAmelCase							=     ["""pixel_values"""]
            self.assertListEqual(arg_names[:1]					,       A__       )





      def        _lowercase				(		self						:					int       )    ->   Optional[int]:






         """simple docstring"""







         UpperCAmelCase							=     self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*A__       )





      def        _lowercase				(		self						:					Optional[int]       )    ->   Tuple:






         """simple docstring"""







         UpperCAmelCase							=     self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_pretraining(*A__       )





      def        _lowercase				(		self						:					int       )    ->   Union[str, Any]:






         """simple docstring"""







         np.random.seed(2       )

         UpperCAmelCase				,  UpperCAmelCase							=     self.model_tester.prepare_config_and_inputs_for_common()

         UpperCAmelCase							=     int((config.image_size // config.patch_size) ** 2       )
         UpperCAmelCase							=     np.random.uniform(size=(self.model_tester.batch_size, num_patches)       )

         for model_class in self.all_model_classes:
            UpperCAmelCase							=     model_class(A__       )
            UpperCAmelCase							=     self._prepare_for_class(A__					,       A__       )

            UpperCAmelCase							=     model(A__					,       noise=A__       )

            UpperCAmelCase							=     copy.deepcopy(self._prepare_for_class(A__					,       A__       )       )
            UpperCAmelCase							=     model(**A__					,       noise=A__       )
            UpperCAmelCase							=     outputs_dict[0].numpy()
            UpperCAmelCase							=     outputs_keywords[0].numpy()

            self.assertLess(np.sum(np.abs(output_dict - output_keywords       )       )					,       1e-6       )





      def        _lowercase				(		self						:					Union[str, Any]       )    ->   Optional[Any]:






         """simple docstring"""







         np.random.seed(2       )

         UpperCAmelCase				,  UpperCAmelCase							=     self.model_tester.prepare_config_and_inputs_for_common()

         UpperCAmelCase							=     int((config.image_size // config.patch_size) ** 2       )
         UpperCAmelCase							=     np.random.uniform(size=(self.model_tester.batch_size, num_patches)       )

         def prepare_numpy_arrays(__lowerCamelCase						:					Union[str, Any]       ):
            UpperCAmelCase							=     {}
            for k, v in inputs_dict.items():
               if tf.is_tensor(A__       ):
                  UpperCAmelCase							=     v.numpy()
               else:
                  UpperCAmelCase							=     np.array(A__       )

            return inputs_np_dict

         for model_class in self.all_model_classes:
            UpperCAmelCase							=     model_class(A__       )

            UpperCAmelCase							=     self._prepare_for_class(A__					,       A__       )
            UpperCAmelCase							=     prepare_numpy_arrays(A__       )

            UpperCAmelCase							=     model(A__					,       noise=A__       )
            UpperCAmelCase							=     model(**A__					,       noise=A__       )
            self.assert_outputs_same(A__					,       A__       )





      def        _lowercase				(		self						:					Optional[Any]					,       __lowerCamelCase						:					Optional[int]					,       __lowerCamelCase						:					str					,       __lowerCamelCase						:					Dict       )    ->   Any:






         """simple docstring"""







         np.random.seed(2       )

         UpperCAmelCase							=     int((tf_model.config.image_size // tf_model.config.patch_size) ** 2       )
         UpperCAmelCase							=     np.random.uniform(size=(self.model_tester.batch_size, num_patches)       )
         UpperCAmelCase							=     tf.constant(A__       )

         # Add `noise` argument.
         # PT inputs will be prepared in `super().check_pt_tf_models()` with this added `noise` argument
         UpperCAmelCase							=     tf_noise

         super().check_pt_tf_models(A__					,       A__					,       A__       )





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






         """simple docstring"""







         np.random.seed(2       )

         UpperCAmelCase				,  UpperCAmelCase							=     self.model_tester.prepare_config_and_inputs_for_common()

         UpperCAmelCase							=     {
             module_member
             for model_class in self.all_model_classes
             for module in (import_module(model_class.__module__       ),)
             for module_member_name in dir(A__       )
             if module_member_name.endswith("""MainLayer"""       )
             # This condition is required, since `modeling_tf_clip.py` has 3 classes whose names end with `MainLayer`.
             and module_member_name[: -len("""MainLayer"""       )] == model_class.__name__[: -len("""Model"""       )]
             for module_member in (getattr(A__					,       A__       ),)
             if isinstance(A__					,       A__       )
             and tf.keras.layers.Layer in module_member.__bases__
             and getattr(A__					,       """_keras_serializable"""					,       A__       )
         }

         UpperCAmelCase							=     int((config.image_size // config.patch_size) ** 2       )
         UpperCAmelCase							=     np.random.uniform(size=(self.model_tester.batch_size, num_patches)       )
         UpperCAmelCase							=     tf.convert_to_tensor(A__       )
         inputs_dict.update({"""noise""": noise}       )

         for main_layer_class in tf_main_layer_classes:
            UpperCAmelCase							=     main_layer_class(A__       )

            UpperCAmelCase							=     {
                name: tf.keras.Input(tensor.shape[1:]					,       dtype=tensor.dtype       ) for name, tensor in inputs_dict.items()
            }

            UpperCAmelCase							=     tf.keras.Model(A__					,       outputs=main_layer(A__       )       )
            UpperCAmelCase							=     model(A__       )

            with tempfile.TemporaryDirectory() as tmpdirname:
               UpperCAmelCase							=     os.path.join(A__					,       """keras_model.h5"""       )
               model.save(A__       )
               UpperCAmelCase							=     tf.keras.models.load_model(
                   A__					,       custom_objects={main_layer_class.__name__: main_layer_class}       )
               assert isinstance(A__					,       tf.keras.Model       )
               UpperCAmelCase							=     model(A__       )
               self.assert_outputs_same(A__					,       A__       )





      @slow
      def        _lowercase				(		self						:					Dict       )    ->   int:






         """simple docstring"""







         np.random.seed(2       )

         UpperCAmelCase				,  UpperCAmelCase							=     self.model_tester.prepare_config_and_inputs_for_common()

         UpperCAmelCase							=     int((config.image_size // config.patch_size) ** 2       )
         UpperCAmelCase							=     np.random.uniform(size=(self.model_tester.batch_size, num_patches)       )

         for model_class in self.all_model_classes:
            UpperCAmelCase							=     model_class(A__       )
            UpperCAmelCase							=     self._prepare_for_class(A__					,       A__       )
            UpperCAmelCase							=     model(A__					,       noise=A__       )

            if model_class.__name__ == "TFViTMAEModel":
               UpperCAmelCase							=     outputs.last_hidden_state.numpy()
               UpperCAmelCase							=     0
            else:
               UpperCAmelCase							=     outputs.logits.numpy()
               UpperCAmelCase							=     0

            with tempfile.TemporaryDirectory() as tmpdirname:
               model.save_pretrained(A__					,       saved_model=A__       )
               UpperCAmelCase							=     model_class.from_pretrained(A__       )
               UpperCAmelCase							=     model(A__					,       noise=A__       )

               if model_class.__name__ == "TFViTMAEModel":
                  UpperCAmelCase							=     after_outputs["""last_hidden_state"""].numpy()
                  UpperCAmelCase							=     0
               else:
                  UpperCAmelCase							=     after_outputs["""logits"""].numpy()
                  UpperCAmelCase							=     0

               UpperCAmelCase							=     np.amax(np.abs(out_a - out_a       )       )
               self.assertLessEqual(A__					,       1e-5       )





      def        _lowercase				(		self						:					List[Any]       )    ->   Dict:






         """simple docstring"""







         np.random.seed(2       )

         UpperCAmelCase				,  UpperCAmelCase							=     self.model_tester.prepare_config_and_inputs_for_common()

         UpperCAmelCase							=     int((config.image_size // config.patch_size) ** 2       )
         UpperCAmelCase							=     np.random.uniform(size=(self.model_tester.batch_size, num_patches)       )

         for model_class in self.all_model_classes:
            UpperCAmelCase							=     model_class(A__       )
            UpperCAmelCase							=     self._prepare_for_class(A__					,       A__       )

            UpperCAmelCase							=     model(A__					,       noise=A__       )
            UpperCAmelCase							=     model.get_config()
            # make sure that returned config is jsonifiable, which is required by keras
            json.dumps(A__       )
            UpperCAmelCase							=     model_class.from_config(model.get_config()       )
            # make sure it also accepts a normal config
            UpperCAmelCase							=     model_class.from_config(model.config       )
            UpperCAmelCase							=     new_model(A__       )  # Build model
            new_model.set_weights(model.get_weights()       )
            UpperCAmelCase							=     new_model(A__					,       noise=A__       )

            self.assert_outputs_same(A__					,       A__       )





      @unittest.skip(
          reason="""ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load
    to get deterministic results."""       )
      def        _lowercase				(		self						:					Dict       )    ->   Any:






         """simple docstring"""







         pass





      @unittest.skip(reason="""ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load"""       )
      def        _lowercase				(		self						:					Optional[Any]       )    ->   Tuple:






         """simple docstring"""







         pass





      @slow
      def        _lowercase				(		self						:					Any       )    ->   Dict:






         """simple docstring"""







         UpperCAmelCase							=     TFViTMAEModel.from_pretrained("""google/vit-base-patch16-224"""       )
         self.assertIsNotNone(A__       )

def   _UpperCamelCase				(						)						->List[Any]:
   UpperCAmelCase							=     Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""   )
   return image






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





      @cached_property
      def        _lowercase				(		self						:					Optional[Any]       )    ->   Optional[Any]:






         """simple docstring"""







         return ViTImageProcessor.from_pretrained("""facebook/vit-mae-base"""       ) if is_vision_available() else None





      @slow
      def        _lowercase				(		self						:					Optional[int]       )    ->   List[Any]:






         """simple docstring"""







         np.random.seed(2       )

         UpperCAmelCase							=     TFViTMAEForPreTraining.from_pretrained("""facebook/vit-mae-base"""       )

         UpperCAmelCase							=     self.default_image_processor
         UpperCAmelCase							=     prepare_img()
         UpperCAmelCase							=     image_processor(images=A__					,       return_tensors="""tf"""       )

         # prepare a noise vector that will be also used for testing the TF model
         # (this way we can ensure that the PT and TF models operate on the same inputs)
         UpperCAmelCase							=     ViTMAEConfig()
         UpperCAmelCase							=     int((vit_mae_config.image_size // vit_mae_config.patch_size) ** 2       )
         UpperCAmelCase							=     np.random.uniform(size=(1, num_patches)       )

         # forward pass
         UpperCAmelCase							=     model(**A__					,       noise=A__       )

         # verify the logits
         UpperCAmelCase							=     tf.convert_to_tensor([1, 1_9_6, 7_6_8]       )
         self.assertEqual(outputs.logits.shape					,       A__       )

         UpperCAmelCase							=     tf.convert_to_tensor(
             [[-0.0_548, -1.7_023, -0.9_325], [0.3_721, -0.5_670, -0.2_233], [0.8_235, -1.3_878, -0.3_524]]       )

         tf.debugging.assert_near(outputs.logits[0, :3, :3]					,       A__					,       atol=1e-4       )







import json
import os
import shutil
import tempfile
import unittest

import numpy as np
import pytest

from transformers import CLIPTokenizer, CLIPTokenizerFast
from transformers.models.clip.tokenization_clip import VOCAB_FILES_NAMES
from transformers.testing_utils import require_vision
from transformers.utils import IMAGE_PROCESSOR_NAME, is_vision_available


if is_vision_available():
 from PIL import Image

 from transformers import OwlViTImageProcessor, OwlViTProcessor






@require_vision
class   __lowercase				(  unittest.TestCase  ):





      def        _lowercase				(		self						:					List[Any]       )    ->   Dict:






         """simple docstring"""







         UpperCAmelCase							=     tempfile.mkdtemp()

         # fmt: off
         UpperCAmelCase							=     ["""""", """l""", """o""", """w""", """e""", """r""", """s""", """t""", """i""", """d""", """n""", """lo""", """l</w>""", """w</w>""", """r</w>""", """t</w>""", """low</w>""", """er</w>""", """lowest</w>""", """newer</w>""", """wider""", """<unk>""", """<|startoftext|>""", """<|endoftext|>"""]
         # fmt: on
         UpperCAmelCase							=     dict(zip(__lowerCamelCase					,       range(len(__lowerCamelCase       )       )       )       )
         UpperCAmelCase							=     ["""#version: 0.2""", """l o""", """lo w</w>""", """e r</w>""", """"""]
         UpperCAmelCase							=     {"""unk_token""": """<unk>"""}

         UpperCAmelCase							=     os.path.join(self.tmpdirname					,       VOCAB_FILES_NAMES["""vocab_file"""]       )
         UpperCAmelCase							=     os.path.join(self.tmpdirname					,       VOCAB_FILES_NAMES["""merges_file"""]       )
         with open(self.vocab_file					,       """w"""					,       encoding="""utf-8"""       ) as fp:
            fp.write(json.dumps(__lowerCamelCase       ) + """\n"""       )
         with open(self.merges_file					,       """w"""					,       encoding="""utf-8"""       ) as fp:
            fp.write("""\n""".join(__lowerCamelCase       )       )

         UpperCAmelCase							=     {
             """do_resize""": True,
             """size""": 2_0,
             """do_center_crop""": True,
             """crop_size""": 1_8,
             """do_normalize""": True,
             """image_mean""": [0.48_145_466, 0.4_578_275, 0.40_821_073],
             """image_std""": [0.26_862_954, 0.26_130_258, 0.27_577_711],
         }
         UpperCAmelCase							=     os.path.join(self.tmpdirname					,       __lowerCamelCase       )
         with open(self.image_processor_file					,       """w"""					,       encoding="""utf-8"""       ) as fp:
            json.dump(__lowerCamelCase					,       __lowerCamelCase       )





      def        _lowercase				(		self						:					List[Any]					,       **__lowerCamelCase						:					Union[str, Any]       )    ->   int:






         """simple docstring"""







         return CLIPTokenizer.from_pretrained(self.tmpdirname					,       pad_token="""!"""					,       **__lowerCamelCase       )





      def        _lowercase				(		self						:					Optional[Any]					,       **__lowerCamelCase						:					List[str]       )    ->   str:






         """simple docstring"""







         return CLIPTokenizerFast.from_pretrained(self.tmpdirname					,       pad_token="""!"""					,       **__lowerCamelCase       )





      def        _lowercase				(		self						:					Union[str, Any]					,       **__lowerCamelCase						:					Optional[Any]       )    ->   Optional[int]:






         """simple docstring"""







         return OwlViTImageProcessor.from_pretrained(self.tmpdirname					,       **__lowerCamelCase       )





      def        _lowercase				(		self						:					Any       )    ->   List[str]:






         """simple docstring"""







         shutil.rmtree(self.tmpdirname       )





      def        _lowercase				(		self						:					List[Any]       )    ->   Optional[Any]:






         """simple docstring"""







         UpperCAmelCase							=     [np.random.randint(2_5_5					,       size=(3, 3_0, 4_0_0)					,       dtype=np.uinta       )]

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

         return image_inputs





      def        _lowercase				(		self						:					int       )    ->   Optional[int]:






         """simple docstring"""







         UpperCAmelCase							=     self.get_tokenizer()
         UpperCAmelCase							=     self.get_rust_tokenizer()
         UpperCAmelCase							=     self.get_image_processor()

         UpperCAmelCase							=     OwlViTProcessor(tokenizer=__lowerCamelCase					,       image_processor=__lowerCamelCase       )
         processor_slow.save_pretrained(self.tmpdirname       )
         UpperCAmelCase							=     OwlViTProcessor.from_pretrained(self.tmpdirname					,       use_fast=__lowerCamelCase       )

         UpperCAmelCase							=     OwlViTProcessor(tokenizer=__lowerCamelCase					,       image_processor=__lowerCamelCase       )
         processor_fast.save_pretrained(self.tmpdirname       )
         UpperCAmelCase							=     OwlViTProcessor.from_pretrained(self.tmpdirname       )

         self.assertEqual(processor_slow.tokenizer.get_vocab()					,       tokenizer_slow.get_vocab()       )
         self.assertEqual(processor_fast.tokenizer.get_vocab()					,       tokenizer_fast.get_vocab()       )
         self.assertEqual(tokenizer_slow.get_vocab()					,       tokenizer_fast.get_vocab()       )
         self.assertIsInstance(processor_slow.tokenizer					,       __lowerCamelCase       )
         self.assertIsInstance(processor_fast.tokenizer					,       __lowerCamelCase       )

         self.assertEqual(processor_slow.image_processor.to_json_string()					,       image_processor.to_json_string()       )
         self.assertEqual(processor_fast.image_processor.to_json_string()					,       image_processor.to_json_string()       )
         self.assertIsInstance(processor_slow.image_processor					,       __lowerCamelCase       )
         self.assertIsInstance(processor_fast.image_processor					,       __lowerCamelCase       )





      def        _lowercase				(		self						:					str       )    ->   Dict:






         """simple docstring"""







         UpperCAmelCase							=     OwlViTProcessor(tokenizer=self.get_tokenizer()					,       image_processor=self.get_image_processor()       )
         processor.save_pretrained(self.tmpdirname       )

         UpperCAmelCase							=     self.get_tokenizer(bos_token="""(BOS)"""					,       eos_token="""(EOS)"""       )
         UpperCAmelCase							=     self.get_image_processor(do_normalize=__lowerCamelCase       )

         UpperCAmelCase							=     OwlViTProcessor.from_pretrained(
             self.tmpdirname					,       bos_token="""(BOS)"""					,       eos_token="""(EOS)"""					,       do_normalize=__lowerCamelCase       )

         self.assertEqual(processor.tokenizer.get_vocab()					,       tokenizer_add_kwargs.get_vocab()       )
         self.assertIsInstance(processor.tokenizer					,       __lowerCamelCase       )

         self.assertEqual(processor.image_processor.to_json_string()					,       image_processor_add_kwargs.to_json_string()       )
         self.assertIsInstance(processor.image_processor					,       __lowerCamelCase       )





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






         """simple docstring"""







         UpperCAmelCase							=     self.get_image_processor()
         UpperCAmelCase							=     self.get_tokenizer()

         UpperCAmelCase							=     OwlViTProcessor(tokenizer=__lowerCamelCase					,       image_processor=__lowerCamelCase       )

         UpperCAmelCase							=     self.prepare_image_inputs()

         UpperCAmelCase							=     image_processor(__lowerCamelCase					,       return_tensors="""np"""       )
         UpperCAmelCase							=     processor(images=__lowerCamelCase					,       return_tensors="""np"""       )

         for key in input_image_proc.keys():
            self.assertAlmostEqual(input_image_proc[key].sum()					,       input_processor[key].sum()					,       delta=1e-2       )





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






         """simple docstring"""







         UpperCAmelCase							=     self.get_image_processor()
         UpperCAmelCase							=     self.get_tokenizer()

         UpperCAmelCase							=     OwlViTProcessor(tokenizer=__lowerCamelCase					,       image_processor=__lowerCamelCase       )

         UpperCAmelCase							=     """lower newer"""

         UpperCAmelCase							=     processor(text=__lowerCamelCase					,       return_tensors="""np"""       )

         UpperCAmelCase							=     tokenizer(__lowerCamelCase					,       return_tensors="""np"""       )

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





      def        _lowercase				(		self						:					Union[str, Any]       )    ->   List[str]:






         """simple docstring"""







         UpperCAmelCase							=     self.get_image_processor()
         UpperCAmelCase							=     self.get_tokenizer()

         UpperCAmelCase							=     OwlViTProcessor(tokenizer=__lowerCamelCase					,       image_processor=__lowerCamelCase       )

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

         UpperCAmelCase							=     processor(text=__lowerCamelCase					,       images=__lowerCamelCase       )

         self.assertListEqual(list(inputs.keys()       )					,       ["""input_ids""", """attention_mask""", """pixel_values"""]       )

         # test if it raises when no input is passed
         with pytest.raises(__lowerCamelCase       ):
            processor()





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






         """simple docstring"""







         UpperCAmelCase							=     """google/owlvit-base-patch32"""
         UpperCAmelCase							=     OwlViTProcessor.from_pretrained(__lowerCamelCase       )

         UpperCAmelCase							=     ["""cat""", """nasa badge"""]
         UpperCAmelCase							=     processor(text=__lowerCamelCase       )

         UpperCAmelCase							=     1_6
         self.assertListEqual(list(inputs.keys()       )					,       ["""input_ids""", """attention_mask"""]       )
         self.assertEqual(inputs["""input_ids"""].shape					,       (2, seq_length)       )

         # test if it raises when no input is passed
         with pytest.raises(__lowerCamelCase       ):
            processor()





      def        _lowercase				(		self						:					Any       )    ->   int:






         """simple docstring"""







         UpperCAmelCase							=     """google/owlvit-base-patch32"""
         UpperCAmelCase							=     OwlViTProcessor.from_pretrained(__lowerCamelCase       )

         UpperCAmelCase							=     [["""cat""", """nasa badge"""], ["""person"""]]
         UpperCAmelCase							=     processor(text=__lowerCamelCase       )

         UpperCAmelCase							=     1_6
         UpperCAmelCase							=     len(__lowerCamelCase       )
         UpperCAmelCase							=     max([len(__lowerCamelCase       ) for texts in input_texts]       )

         self.assertListEqual(list(inputs.keys()       )					,       ["""input_ids""", """attention_mask"""]       )
         self.assertEqual(inputs["""input_ids"""].shape					,       (batch_size * num_max_text_queries, seq_length)       )

         # test if it raises when no input is passed
         with pytest.raises(__lowerCamelCase       ):
            processor()





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






         """simple docstring"""







         UpperCAmelCase							=     """google/owlvit-base-patch32"""
         UpperCAmelCase							=     OwlViTProcessor.from_pretrained(__lowerCamelCase       )

         UpperCAmelCase							=     ["""cat""", """nasa badge"""]
         UpperCAmelCase							=     processor(text=__lowerCamelCase       )

         UpperCAmelCase							=     1_6
         UpperCAmelCase							=     inputs["""input_ids"""]
         UpperCAmelCase							=     [
             [4_9_4_0_6, 2_3_6_8, 4_9_4_0_7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
             [4_9_4_0_6, 6_8_4_1, 1_1_3_0_1, 4_9_4_0_7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
         ]

         self.assertListEqual(list(inputs.keys()       )					,       ["""input_ids""", """attention_mask"""]       )
         self.assertEqual(inputs["""input_ids"""].shape					,       (2, seq_length)       )
         self.assertListEqual(list(input_ids[0]       )					,       predicted_ids[0]       )
         self.assertListEqual(list(input_ids[1]       )					,       predicted_ids[1]       )





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






         """simple docstring"""







         UpperCAmelCase							=     self.get_image_processor()
         UpperCAmelCase							=     self.get_tokenizer()

         UpperCAmelCase							=     OwlViTProcessor(tokenizer=__lowerCamelCase					,       image_processor=__lowerCamelCase       )

         UpperCAmelCase							=     self.prepare_image_inputs()
         UpperCAmelCase							=     self.prepare_image_inputs()

         UpperCAmelCase							=     processor(images=__lowerCamelCase					,       query_images=__lowerCamelCase       )

         self.assertListEqual(list(inputs.keys()       )					,       ["""query_pixel_values""", """pixel_values"""]       )

         # test if it raises when no input is passed
         with pytest.raises(__lowerCamelCase       ):
            processor()





      def        _lowercase				(		self						:					Tuple       )    ->   Any:






         """simple docstring"""







         UpperCAmelCase							=     self.get_image_processor()
         UpperCAmelCase							=     self.get_tokenizer()

         UpperCAmelCase							=     OwlViTProcessor(tokenizer=__lowerCamelCase					,       image_processor=__lowerCamelCase       )

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

         UpperCAmelCase							=     processor.batch_decode(__lowerCamelCase       )
         UpperCAmelCase							=     tokenizer.batch_decode(__lowerCamelCase       )

         self.assertListEqual(__lowerCamelCase					,       __lowerCamelCase       )



