


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     A__   (       unittest.TestCase      ):







    """simple docstring"""

    def 						a_     (			self       ):
         snake_case											=							tempfile.mkdtemp()

         # fmt: off
         snake_case											=							['''''', '''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
         snake_case											=							dict(zip(__snake_case     ,   range(len(__snake_case       )       )       )       )
         snake_case											=							['''#version: 0.2''', '''l o''', '''lo w</w>''', '''e r</w>''', '''''']
         snake_case											=							{'''unk_token''': '''<unk>'''}

         snake_case											=							os.path.join(self.tmpdirname     ,   VOCAB_FILES_NAMES['''vocab_file''']       )
         snake_case											=							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(__snake_case       ) + '''\n'''       )
         with open(self.merges_file     ,   '''w'''     ,   encoding='''utf-8'''       ) as fp:
              fp.write('''\n'''.join(__snake_case       )       )

         snake_case											=							{
             '''do_resize''': True,
             '''size''': 2_0,
             '''do_center_crop''': True,
             '''crop_size''': 1_8,
             '''do_normalize''': True,
             '''image_mean''': [0.4814_5466, 0.457_8275, 0.4082_1073],
             '''image_std''': [0.2686_2954, 0.2613_0258, 0.2757_7711],
         }
         snake_case											=							os.path.join(self.tmpdirname     ,   __snake_case       )
         with open(self.image_processor_file     ,   '''w'''     ,   encoding='''utf-8'''       ) as fp:
              json.dump(__snake_case     ,   __snake_case       )
    def 						a_     (			self     ,   **__snake_case       ):
         return CLIPTokenizer.from_pretrained(self.tmpdirname     ,   pad_token='''!'''     ,   **__snake_case       )
    def 						a_     (			self     ,   **__snake_case       ):
         return CLIPTokenizerFast.from_pretrained(self.tmpdirname     ,   pad_token='''!'''     ,   **__snake_case       )
    def 						a_     (			self     ,   **__snake_case       ):
         return OwlViTImageProcessor.from_pretrained(self.tmpdirname     ,   **__snake_case       )
    def 						a_     (			self       ):
         shutil.rmtree(self.tmpdirname       )
    def 						a_     (			self       ):
         snake_case											=							[np.random.randint(2_5_5     ,   size=(3, 3_0, 4_0_0)     ,   dtype=np.uinta       )]

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

         return image_inputs
    def 						a_     (			self       ):
         snake_case											=							self.get_tokenizer()
         snake_case											=							self.get_rust_tokenizer()
         snake_case											=							self.get_image_processor()

         snake_case											=							OwlViTProcessor(tokenizer=__snake_case     ,   image_processor=__snake_case       )
         processor_slow.save_pretrained(self.tmpdirname       )
         snake_case											=							OwlViTProcessor.from_pretrained(self.tmpdirname     ,   use_fast=__snake_case       )

         snake_case											=							OwlViTProcessor(tokenizer=__snake_case     ,   image_processor=__snake_case       )
         processor_fast.save_pretrained(self.tmpdirname       )
         snake_case											=							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     ,   __snake_case       )
         self.assertIsInstance(processor_fast.tokenizer     ,   __snake_case       )

         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     ,   __snake_case       )
         self.assertIsInstance(processor_fast.image_processor     ,   __snake_case       )
    def 						a_     (			self       ):
         snake_case											=							OwlViTProcessor(tokenizer=self.get_tokenizer()     ,   image_processor=self.get_image_processor()       )
         processor.save_pretrained(self.tmpdirname       )

         snake_case											=							self.get_tokenizer(bos_token='''(BOS)'''     ,   eos_token='''(EOS)'''       )
         snake_case											=							self.get_image_processor(do_normalize=__snake_case       )

         snake_case											=							OwlViTProcessor.from_pretrained(
             self.tmpdirname     ,   bos_token='''(BOS)'''     ,   eos_token='''(EOS)'''     ,   do_normalize=__snake_case       )

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

         self.assertEqual(processor.image_processor.to_json_string()     ,   image_processor_add_kwargs.to_json_string()       )
         self.assertIsInstance(processor.image_processor     ,   __snake_case       )
    def 						a_     (			self       ):
         snake_case											=							self.get_image_processor()
         snake_case											=							self.get_tokenizer()

         snake_case											=							OwlViTProcessor(tokenizer=__snake_case     ,   image_processor=__snake_case       )

         snake_case											=							self.prepare_image_inputs()

         snake_case											=							image_processor(__snake_case     ,   return_tensors='''np'''       )
         snake_case											=							processor(images=__snake_case     ,   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 						a_     (			self       ):
         snake_case											=							self.get_image_processor()
         snake_case											=							self.get_tokenizer()

         snake_case											=							OwlViTProcessor(tokenizer=__snake_case     ,   image_processor=__snake_case       )

         snake_case											=							'''lower newer'''

         snake_case											=							processor(text=__snake_case     ,   return_tensors='''np'''       )

         snake_case											=							tokenizer(__snake_case     ,   return_tensors='''np'''       )

         for key in encoded_tok.keys():
              self.assertListEqual(encoded_tok[key][0].tolist()     ,   encoded_processor[key][0].tolist()       )
    def 						a_     (			self       ):
         snake_case											=							self.get_image_processor()
         snake_case											=							self.get_tokenizer()

         snake_case											=							OwlViTProcessor(tokenizer=__snake_case     ,   image_processor=__snake_case       )

         snake_case											=							'''lower newer'''
         snake_case											=							self.prepare_image_inputs()

         snake_case											=							processor(text=__snake_case     ,   images=__snake_case       )

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

         # test if it raises when no input is passed
         with pytest.raises(__snake_case       ):
              processor()
    def 						a_     (			self       ):
         snake_case											=							'''google/owlvit-base-patch32'''
         snake_case											=							OwlViTProcessor.from_pretrained(__snake_case       )

         snake_case											=							['''cat''', '''nasa badge''']
         snake_case											=							processor(text=__snake_case       )

         snake_case											=							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(__snake_case       ):
              processor()
    def 						a_     (			self       ):
         snake_case											=							'''google/owlvit-base-patch32'''
         snake_case											=							OwlViTProcessor.from_pretrained(__snake_case       )

         snake_case											=							[['''cat''', '''nasa badge'''], ['''person''']]
         snake_case											=							processor(text=__snake_case       )

         snake_case											=							1_6
         snake_case											=							len(__snake_case       )
         snake_case											=							max([len(__snake_case       ) 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(__snake_case       ):
              processor()
    def 						a_     (			self       ):
         snake_case											=							'''google/owlvit-base-patch32'''
         snake_case											=							OwlViTProcessor.from_pretrained(__snake_case       )

         snake_case											=							['''cat''', '''nasa badge''']
         snake_case											=							processor(text=__snake_case       )

         snake_case											=							1_6
         snake_case											=							inputs['''input_ids''']
         snake_case											=							[
             [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 						a_     (			self       ):
         snake_case											=							self.get_image_processor()
         snake_case											=							self.get_tokenizer()

         snake_case											=							OwlViTProcessor(tokenizer=__snake_case     ,   image_processor=__snake_case       )

         snake_case											=							self.prepare_image_inputs()
         snake_case											=							self.prepare_image_inputs()

         snake_case											=							processor(images=__snake_case     ,   query_images=__snake_case       )

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

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




    def 						a_     (			self       ):
         snake_case											=							self.get_image_processor()
         snake_case											=							self.get_tokenizer()

         snake_case											=							OwlViTProcessor(tokenizer=__snake_case     ,   image_processor=__snake_case       )

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

         snake_case											=							processor.batch_decode(__snake_case       )
         snake_case											=							tokenizer.batch_decode(__snake_case       )

         self.assertListEqual(__snake_case     ,   __snake_case       )








from collections import OrderedDict
from typing import Mapping

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


_SCREAMING_SNAKE_CASE     :					Optional[Any]      =       logging.get_logger(__name__)

_SCREAMING_SNAKE_CASE     :					int      =       {
    "facebook/deit-base-distilled-patch16-224": (
        "https://huggingface.co/facebook/deit-base-patch16-224/resolve/main/config.json"
    ),
    # See all DeiT models at https://huggingface.co/models?filter=deit
}

class     A__   (       snake_case__      ):







    """simple docstring"""

    __magic_name__         =						'deit'
    def __init__(			self     ,   __snake_case=7_6_8     ,   __snake_case=1_2     ,   __snake_case=1_2     ,   __snake_case=3_0_7_2     ,   __snake_case="gelu"     ,   __snake_case=0.0     ,   __snake_case=0.0     ,   __snake_case=0.02     ,   __snake_case=1E-12     ,   __snake_case=2_2_4     ,   __snake_case=1_6     ,   __snake_case=3     ,   __snake_case=True     ,   __snake_case=1_6     ,   **__snake_case     ,   ):
         super().__init__(**__snake_case       )

         snake_case											=							hidden_size
         snake_case											=							num_hidden_layers
         snake_case											=							num_attention_heads
         snake_case											=							intermediate_size
         snake_case											=							hidden_act
         snake_case											=							hidden_dropout_prob
         snake_case											=							attention_probs_dropout_prob
         snake_case											=							initializer_range
         snake_case											=							layer_norm_eps
         snake_case											=							image_size
         snake_case											=							patch_size
         snake_case											=							num_channels
         snake_case											=							qkv_bias
         snake_case											=							encoder_stride






class     A__   (       snake_case__      ):







    """simple docstring"""

    __magic_name__         =						version.parse('1.11'      )
    @property
    def 						a_     (			self       ):
         return OrderedDict(
             [
                 ('''pixel_values''', {0: '''batch''', 1: '''num_channels''', 2: '''height''', 3: '''width'''}),
             ]       )




    @property
    def 						a_     (			self       ):
         return 1E-4




