



"""simple docstring"""






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



   def    __UpperCAmelCase    (       self    :	List[str]				):



     """simple docstring"""
     _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(__lowerCamelCase							,       range(len(__lowerCamelCase				)				)				)				)
     _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(__lowerCamelCase				) + '''\n'''				)
     with open(self.merges_file							,       '''w'''							,       encoding='''utf-8'''				) as fp:
       fp.write('''\n'''.join(__lowerCamelCase				)				)

     _snake_case   	=      {
         '''do_resize''': True,
         '''size''': 2_0,
         '''do_center_crop''': True,
         '''crop_size''': 1_8,
         '''do_normalize''': True,
         '''image_mean''': [0.4_8_1_4_5_4_6_6, 0.4_5_7_8_2_7_5, 0.4_0_8_2_1_0_7_3],
         '''image_std''': [0.2_6_8_6_2_9_5_4, 0.2_6_1_3_0_2_5_8, 0.2_7_5_7_7_7_1_1],
     }
     _snake_case   	=      os.path.join(self.tmpdirname							,       __lowerCamelCase				)
     with open(self.image_processor_file							,       '''w'''							,       encoding='''utf-8'''				) as fp:
       json.dump(__lowerCamelCase							,       __lowerCamelCase				)



   def    __UpperCAmelCase    (       self    :	int							,       **__lowerCamelCase    :	List[str]				):



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



   def    __UpperCAmelCase    (       self    :	List[Any]							,       **__lowerCamelCase    :	List[str]				):



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



   def    __UpperCAmelCase    (       self    :	Tuple							,       **__lowerCamelCase    :	Dict				):



     """simple docstring"""
     return OwlViTImageProcessor.from_pretrained(self.tmpdirname							,       **__lowerCamelCase				)



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



     """simple docstring"""
     shutil.rmtree(self.tmpdirname				)



   def    __UpperCAmelCase    (       self    :	Dict				):



     """simple docstring"""
     _snake_case   	=      [np.random.randint(2_5_5							,       size=(3, 3_0, 4_0_0)							,       dtype=np.uinta				)]

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

     return image_inputs



   def    __UpperCAmelCase    (       self    :	int				):



     """simple docstring"""
     _snake_case   	=      self.get_tokenizer()
     _snake_case   	=      self.get_rust_tokenizer()
     _snake_case   	=      self.get_image_processor()

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

     _snake_case   	=      OwlViTProcessor(tokenizer=__lowerCamelCase							,       image_processor=__lowerCamelCase				)
     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							,       __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    __UpperCAmelCase    (       self    :	Union[str, Any]				):



     """simple docstring"""
     _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=__lowerCamelCase				)

     _snake_case   	=      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    __UpperCAmelCase    (       self    :	Optional[Any]				):



     """simple docstring"""
     _snake_case   	=      self.get_image_processor()
     _snake_case   	=      self.get_tokenizer()

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

     _snake_case   	=      self.prepare_image_inputs()

     _snake_case   	=      image_processor(__lowerCamelCase							,       return_tensors='''np'''				)
     _snake_case   	=      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    __UpperCAmelCase    (       self    :	Tuple				):



     """simple docstring"""
     _snake_case   	=      self.get_image_processor()
     _snake_case   	=      self.get_tokenizer()

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

     _snake_case   	=      '''lower newer'''

     _snake_case   	=      processor(text=__lowerCamelCase							,       return_tensors='''np'''				)

     _snake_case   	=      tokenizer(__lowerCamelCase							,       return_tensors='''np'''				)

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



   def    __UpperCAmelCase    (       self    :	List[Any]				):



     """simple docstring"""
     _snake_case   	=      self.get_image_processor()
     _snake_case   	=      self.get_tokenizer()

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

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

     _snake_case   	=      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    __UpperCAmelCase    (       self    :	Any				):



     """simple docstring"""
     _snake_case   	=      '''google/owlvit-base-patch32'''
     _snake_case   	=      OwlViTProcessor.from_pretrained(__lowerCamelCase				)

     _snake_case   	=      ['''cat''', '''nasa badge''']
     _snake_case   	=      processor(text=__lowerCamelCase				)

     _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(__lowerCamelCase				):
       processor()



   def    __UpperCAmelCase    (       self    :	Optional[int]				):



     """simple docstring"""
     _snake_case   	=      '''google/owlvit-base-patch32'''
     _snake_case   	=      OwlViTProcessor.from_pretrained(__lowerCamelCase				)

     _snake_case   	=      [['''cat''', '''nasa badge'''], ['''person''']]
     _snake_case   	=      processor(text=__lowerCamelCase				)

     _snake_case   	=      1_6
     _snake_case   	=      len(__lowerCamelCase				)
     _snake_case   	=      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    __UpperCAmelCase    (       self    :	Any				):



     """simple docstring"""
     _snake_case   	=      '''google/owlvit-base-patch32'''
     _snake_case   	=      OwlViTProcessor.from_pretrained(__lowerCamelCase				)

     _snake_case   	=      ['''cat''', '''nasa badge''']
     _snake_case   	=      processor(text=__lowerCamelCase				)

     _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    __UpperCAmelCase    (       self    :	Dict				):



     """simple docstring"""
     _snake_case   	=      self.get_image_processor()
     _snake_case   	=      self.get_tokenizer()

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

     _snake_case   	=      self.prepare_image_inputs()
     _snake_case   	=      self.prepare_image_inputs()

     _snake_case   	=      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    __UpperCAmelCase    (       self    :	str				):



     """simple docstring"""
     _snake_case   	=      self.get_image_processor()
     _snake_case   	=      self.get_tokenizer()

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

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

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

     self.assertListEqual(__lowerCamelCase							,       __lowerCamelCase				)








import baseaa


def 							__lowerCAmelCase     (							_UpperCamelCase		:	str						)		->				bytes:
 '''simple docstring'''


 return baseaa.aaaencode(string.encode('utf-8'						)						)


def 							__lowerCAmelCase     (							_UpperCamelCase		:	bytes						)		->				str:
 '''simple docstring'''


 return baseaa.aaadecode(_UpperCamelCase						).decode('utf-8'						)


if __name__ == "__main__":
      import doctest

      doctest.testmod()

