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


			'''simple docstring'''






			def 				a_			(  self):




					"""simple docstring"""


					lowerCAmelCase     =    tempfile.mkdtemp()

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

					lowerCAmelCase     =    os.path.join(self.tmpdirname			,       VOCAB_FILES_NAMES["""vocab_file"""])
					lowerCAmelCase     =    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))

					lowerCAmelCase     =    {
					    """do_resize""": True,
					    """size""": 20,
					    """do_center_crop""": True,
					    """crop_size""": 18,
					    """do_normalize""": True,
					    """image_mean""": [0.48145466, 0.4578275, 0.40821073],
					    """image_std""": [0.26862954, 0.26130258, 0.27577711],
					}
					lowerCAmelCase     =    os.path.join(self.tmpdirname			,       __lowerCAmelCase)
					with open(self.image_processor_file			,       """w"""			,       encoding="""utf-8""") as fp:
							json.dump(__lowerCAmelCase			,       __lowerCAmelCase)



			def 				a_			(  self			,       **__lowerCAmelCase):




					"""simple docstring"""


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



			def 				a_			(  self			,       **__lowerCAmelCase):




					"""simple docstring"""


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



			def 				a_			(  self			,       **__lowerCAmelCase):




					"""simple docstring"""


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



			def 				a_			(  self):




					"""simple docstring"""


					shutil.rmtree(self.tmpdirname)



			def 				a_			(  self):




					"""simple docstring"""


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

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

					return image_inputs



			def 				a_			(  self):




					"""simple docstring"""


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

					lowerCAmelCase     =    OwlViTProcessor(tokenizer=__lowerCAmelCase			,       image_processor=__lowerCAmelCase)
					processor_slow.save_pretrained(self.tmpdirname)
					lowerCAmelCase     =    OwlViTProcessor.from_pretrained(self.tmpdirname			,       use_fast=__lowerCAmelCase)

					lowerCAmelCase     =    OwlViTProcessor(tokenizer=__lowerCAmelCase			,       image_processor=__lowerCAmelCase)
					processor_fast.save_pretrained(self.tmpdirname)
					lowerCAmelCase     =    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 				a_			(  self):




					"""simple docstring"""


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

					lowerCAmelCase     =    self.get_tokenizer(bos_token="""(BOS)"""			,       eos_token="""(EOS)""")
					lowerCAmelCase     =    self.get_image_processor(do_normalize=__lowerCAmelCase)

					lowerCAmelCase     =    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 				a_			(  self):




					"""simple docstring"""


					lowerCAmelCase     =    self.get_image_processor()
					lowerCAmelCase     =    self.get_tokenizer()

					lowerCAmelCase     =    OwlViTProcessor(tokenizer=__lowerCAmelCase			,       image_processor=__lowerCAmelCase)

					lowerCAmelCase     =    self.prepare_image_inputs()

					lowerCAmelCase     =    image_processor(__lowerCAmelCase			,       return_tensors="""np""")
					lowerCAmelCase     =    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 				a_			(  self):




					"""simple docstring"""


					lowerCAmelCase     =    self.get_image_processor()
					lowerCAmelCase     =    self.get_tokenizer()

					lowerCAmelCase     =    OwlViTProcessor(tokenizer=__lowerCAmelCase			,       image_processor=__lowerCAmelCase)

					lowerCAmelCase     =    """lower newer"""

					lowerCAmelCase     =    processor(text=__lowerCAmelCase			,       return_tensors="""np""")

					lowerCAmelCase     =    tokenizer(__lowerCAmelCase			,       return_tensors="""np""")

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



			def 				a_			(  self):




					"""simple docstring"""


					lowerCAmelCase     =    self.get_image_processor()
					lowerCAmelCase     =    self.get_tokenizer()

					lowerCAmelCase     =    OwlViTProcessor(tokenizer=__lowerCAmelCase			,       image_processor=__lowerCAmelCase)

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

					lowerCAmelCase     =    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 				a_			(  self):




					"""simple docstring"""


					lowerCAmelCase     =    """google/owlvit-base-patch32"""
					lowerCAmelCase     =    OwlViTProcessor.from_pretrained(__lowerCAmelCase)

					lowerCAmelCase     =    ["""cat""", """nasa badge"""]
					lowerCAmelCase     =    processor(text=__lowerCAmelCase)

					lowerCAmelCase     =    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(__lowerCAmelCase):
							processor()



			def 				a_			(  self):




					"""simple docstring"""


					lowerCAmelCase     =    """google/owlvit-base-patch32"""
					lowerCAmelCase     =    OwlViTProcessor.from_pretrained(__lowerCAmelCase)

					lowerCAmelCase     =    [["""cat""", """nasa badge"""], ["""person"""]]
					lowerCAmelCase     =    processor(text=__lowerCAmelCase)

					lowerCAmelCase     =    16
					lowerCAmelCase     =    len(__lowerCAmelCase)
					lowerCAmelCase     =    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 				a_			(  self):




					"""simple docstring"""


					lowerCAmelCase     =    """google/owlvit-base-patch32"""
					lowerCAmelCase     =    OwlViTProcessor.from_pretrained(__lowerCAmelCase)

					lowerCAmelCase     =    ["""cat""", """nasa badge"""]
					lowerCAmelCase     =    processor(text=__lowerCAmelCase)

					lowerCAmelCase     =    16
					lowerCAmelCase     =    inputs["""input_ids"""]
					lowerCAmelCase     =    [
					    [49406, 2368, 49407, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
					    [49406, 6841, 11301, 49407, 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):




					"""simple docstring"""


					lowerCAmelCase     =    self.get_image_processor()
					lowerCAmelCase     =    self.get_tokenizer()

					lowerCAmelCase     =    OwlViTProcessor(tokenizer=__lowerCAmelCase			,       image_processor=__lowerCAmelCase)

					lowerCAmelCase     =    self.prepare_image_inputs()
					lowerCAmelCase     =    self.prepare_image_inputs()

					lowerCAmelCase     =    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 				a_			(  self):




					"""simple docstring"""


					lowerCAmelCase     =    self.get_image_processor()
					lowerCAmelCase     =    self.get_tokenizer()

					lowerCAmelCase     =    OwlViTProcessor(tokenizer=__lowerCAmelCase			,       image_processor=__lowerCAmelCase)

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

					lowerCAmelCase     =    processor.batch_decode(__lowerCAmelCase)
					lowerCAmelCase     =    tokenizer.batch_decode(__lowerCAmelCase)

					self.assertListEqual(__lowerCAmelCase			,       __lowerCAmelCase)





'''simple docstring'''




from collections import OrderedDict
from typing import Mapping

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig


__lowercase        =    {
    '''albert-base-v1''': '''https://huggingface.co/albert-base-v1/resolve/main/config.json''',
    '''albert-large-v1''': '''https://huggingface.co/albert-large-v1/resolve/main/config.json''',
    '''albert-xlarge-v1''': '''https://huggingface.co/albert-xlarge-v1/resolve/main/config.json''',
    '''albert-xxlarge-v1''': '''https://huggingface.co/albert-xxlarge-v1/resolve/main/config.json''',
    '''albert-base-v2''': '''https://huggingface.co/albert-base-v2/resolve/main/config.json''',
    '''albert-large-v2''': '''https://huggingface.co/albert-large-v2/resolve/main/config.json''',
    '''albert-xlarge-v2''': '''https://huggingface.co/albert-xlarge-v2/resolve/main/config.json''',
    '''albert-xxlarge-v2''': '''https://huggingface.co/albert-xxlarge-v2/resolve/main/config.json''',
}






class 							a__(   lowerCAmelCase__      ):


			'''simple docstring'''






			UpperCAmelCase_     :	List[str]						=			'''albert'''



			def __init__(  self			,       __lowerCAmelCase=30000			,       __lowerCAmelCase=128			,       __lowerCAmelCase=4096			,       __lowerCAmelCase=12			,       __lowerCAmelCase=1			,       __lowerCAmelCase=64			,       __lowerCAmelCase=16384			,       __lowerCAmelCase=1			,       __lowerCAmelCase="gelu_new"			,       __lowerCAmelCase=0			,       __lowerCAmelCase=0			,       __lowerCAmelCase=512			,       __lowerCAmelCase=2			,       __lowerCAmelCase=0.02			,       __lowerCAmelCase=1E-1_2			,       __lowerCAmelCase=0.1			,       __lowerCAmelCase="absolute"			,       __lowerCAmelCase=0			,       __lowerCAmelCase=2			,       __lowerCAmelCase=3			,       **__lowerCAmelCase			,       ):




					"""simple docstring"""


					super().__init__(pad_token_id=__lowerCAmelCase			,       bos_token_id=__lowerCAmelCase			,       eos_token_id=__lowerCAmelCase			,       **__lowerCAmelCase)

					lowerCAmelCase     =    vocab_size
					lowerCAmelCase     =    embedding_size
					lowerCAmelCase     =    hidden_size
					lowerCAmelCase     =    num_hidden_layers
					lowerCAmelCase     =    num_hidden_groups
					lowerCAmelCase     =    num_attention_heads
					lowerCAmelCase     =    inner_group_num
					lowerCAmelCase     =    hidden_act
					lowerCAmelCase     =    intermediate_size
					lowerCAmelCase     =    hidden_dropout_prob
					lowerCAmelCase     =    attention_probs_dropout_prob
					lowerCAmelCase     =    max_position_embeddings
					lowerCAmelCase     =    type_vocab_size
					lowerCAmelCase     =    initializer_range
					lowerCAmelCase     =    layer_norm_eps
					lowerCAmelCase     =    classifier_dropout_prob
					lowerCAmelCase     =    position_embedding_type







class 							a__(   lowerCAmelCase__      ):


			'''simple docstring'''






			@property
			def 				a_			(  self):




					"""simple docstring"""


					if self.task == "multiple-choice":
							lowerCAmelCase     =    {0: """batch""", 1: """choice""", 2: """sequence"""}
					else:
							lowerCAmelCase     =    {0: """batch""", 1: """sequence"""}
					return OrderedDict(
					    [
					        ("""input_ids""", dynamic_axis),
					        ("""attention_mask""", dynamic_axis),
					        ("""token_type_ids""", dynamic_axis),
					    ])




