
'''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 		lowercase_  (	self     :Tuple	) ->	Dict:







       '''simple docstring'''



       __A						=	tempfile.mkdtemp()

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

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

       __A						=	{
           'do_resize': True,
           'size': 20,
           'do_center_crop': True,
           'crop_size': 18,
           '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],
       }
       __A						=	os.path.join(self.tmpdirname		, UpperCamelCase_	)
       with open(self.image_processor_file		, 'w'		, encoding='utf-8'	) as fp:
             json.dump(UpperCamelCase_		, UpperCamelCase_	)






 def 		lowercase_  (	self     :List[str]		, **_A     :str	) ->	Tuple:







       '''simple docstring'''



       return CLIPTokenizer.from_pretrained(self.tmpdirname		, pad_token='!'		, **UpperCamelCase_	)






 def 		lowercase_  (	self     :Optional[Any]		, **_A     :str	) ->	Dict:







       '''simple docstring'''



       return CLIPTokenizerFast.from_pretrained(self.tmpdirname		, pad_token='!'		, **UpperCamelCase_	)






 def 		lowercase_  (	self     :Union[str, Any]		, **_A     :List[str]	) ->	List[Any]:







       '''simple docstring'''



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






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







       '''simple docstring'''



       shutil.rmtree(self.tmpdirname	)






 def 		lowercase_  (	self     :int	) ->	List[Any]:







       '''simple docstring'''



       __A						=	[np.random.randint(255		, size=(3, 30, 400)		, dtype=np.uinta	)]

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

       return image_inputs






 def 		lowercase_  (	self     :Dict	) ->	Optional[int]:







       '''simple docstring'''



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

       __A						=	OwlViTProcessor(tokenizer=UpperCamelCase_		, image_processor=UpperCamelCase_	)
       processor_slow.save_pretrained(self.tmpdirname	)
       __A						=	OwlViTProcessor.from_pretrained(self.tmpdirname		, use_fast=UpperCamelCase_	)

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

       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		, UpperCamelCase_	)
       self.assertIsInstance(processor_fast.image_processor		, UpperCamelCase_	)






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







       '''simple docstring'''



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

       __A						=	self.get_tokenizer(bos_token='(BOS)'		, eos_token='(EOS)'	)
       __A						=	self.get_image_processor(do_normalize=UpperCamelCase_	)

       __A						=	OwlViTProcessor.from_pretrained(
           self.tmpdirname		, bos_token='(BOS)'		, eos_token='(EOS)'		, do_normalize=UpperCamelCase_	)

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

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






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







       '''simple docstring'''



       __A						=	self.get_image_processor()
       __A						=	self.get_tokenizer()

       __A						=	OwlViTProcessor(tokenizer=UpperCamelCase_		, image_processor=UpperCamelCase_	)

       __A						=	self.prepare_image_inputs()

       __A						=	image_processor(UpperCamelCase_		, return_tensors='np'	)
       __A						=	processor(images=UpperCamelCase_		, 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     :Dict	) ->	List[str]:







       '''simple docstring'''



       __A						=	self.get_image_processor()
       __A						=	self.get_tokenizer()

       __A						=	OwlViTProcessor(tokenizer=UpperCamelCase_		, image_processor=UpperCamelCase_	)

       __A						=	'lower newer'

       __A						=	processor(text=UpperCamelCase_		, return_tensors='np'	)

       __A						=	tokenizer(UpperCamelCase_		, return_tensors='np'	)

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






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







       '''simple docstring'''



       __A						=	self.get_image_processor()
       __A						=	self.get_tokenizer()

       __A						=	OwlViTProcessor(tokenizer=UpperCamelCase_		, image_processor=UpperCamelCase_	)

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

       __A						=	processor(text=UpperCamelCase_		, images=UpperCamelCase_	)

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

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






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







       '''simple docstring'''



       __A						=	'google/owlvit-base-patch32'
       __A						=	OwlViTProcessor.from_pretrained(UpperCamelCase_	)

       __A						=	['cat', 'nasa badge']
       __A						=	processor(text=UpperCamelCase_	)

       __A						=	16
       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(UpperCamelCase_	):
             processor()






 def 		lowercase_  (	self     :Any	) ->	str:







       '''simple docstring'''



       __A						=	'google/owlvit-base-patch32'
       __A						=	OwlViTProcessor.from_pretrained(UpperCamelCase_	)

       __A						=	[['cat', 'nasa badge'], ['person']]
       __A						=	processor(text=UpperCamelCase_	)

       __A						=	16
       __A						=	len(UpperCamelCase_	)
       __A						=	max([len(UpperCamelCase_	) 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(UpperCamelCase_	):
             processor()






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







       '''simple docstring'''



       __A						=	'google/owlvit-base-patch32'
       __A						=	OwlViTProcessor.from_pretrained(UpperCamelCase_	)

       __A						=	['cat', 'nasa badge']
       __A						=	processor(text=UpperCamelCase_	)

       __A						=	16
       __A						=	inputs['input_ids']
       __A						=	[
           [49_406, 2_368, 49_407, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
           [49_406, 6_841, 11_301, 49_407, 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     :Union[str, Any]	) ->	Tuple:







       '''simple docstring'''



       __A						=	self.get_image_processor()
       __A						=	self.get_tokenizer()

       __A						=	OwlViTProcessor(tokenizer=UpperCamelCase_		, image_processor=UpperCamelCase_	)

       __A						=	self.prepare_image_inputs()
       __A						=	self.prepare_image_inputs()

       __A						=	processor(images=UpperCamelCase_		, query_images=UpperCamelCase_	)

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

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






 def 		lowercase_  (	self     :str	) ->	Tuple:







       '''simple docstring'''



       __A						=	self.get_image_processor()
       __A						=	self.get_tokenizer()

       __A						=	OwlViTProcessor(tokenizer=UpperCamelCase_		, image_processor=UpperCamelCase_	)

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

       __A						=	processor.batch_decode(UpperCamelCase_	)
       __A						=	tokenizer.batch_decode(UpperCamelCase_	)

       self.assertListEqual(UpperCamelCase_		, UpperCamelCase_	)












from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_sentencepiece_available


UpperCAmelCase_									=	{}


try:
       if not is_sentencepiece_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       UpperCAmelCase_									=	['MLukeTokenizer']

if TYPE_CHECKING:
       try:
              if not is_sentencepiece_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .tokenization_mluke import MLukeTokenizer


else:
       import sys

       UpperCAmelCase_									=	_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)

