"""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			):




					def 						_SCREAMING_SNAKE_CASE						(	self						:     Dict     ):
							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(UpperCamelCase_  ,						range(len(UpperCamelCase_     )     )     )     )
							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(UpperCamelCase_     ) + """\n"""     )
							with open(self.merges_file  ,						"""w"""  ,						encoding="""utf-8"""     ) as fp:
									fp.write("""\n""".join(UpperCamelCase_     )     )

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




					def 						_SCREAMING_SNAKE_CASE						(	self						:     List[Any]  ,						**snake_case__						:     int     ):
							return CLIPTokenizer.from_pretrained(self.tmpdirname  ,						pad_token="""!"""  ,						**UpperCamelCase_     )




					def 						_SCREAMING_SNAKE_CASE						(	self						:     Optional[int]  ,						**snake_case__						:     Union[str, Any]     ):
							return CLIPTokenizerFast.from_pretrained(self.tmpdirname  ,						pad_token="""!"""  ,						**UpperCamelCase_     )




					def 						_SCREAMING_SNAKE_CASE						(	self						:     int  ,						**snake_case__						:     List[Any]     ):
							return OwlViTImageProcessor.from_pretrained(self.tmpdirname  ,						**UpperCamelCase_     )




					def 						_SCREAMING_SNAKE_CASE						(	self						:     int     ):
							shutil.rmtree(self.tmpdirname     )




					def 						_SCREAMING_SNAKE_CASE						(	self						:     Union[str, Any]     ):
							lowerCAmelCase__        =   [np.random.randint(255  ,						size=(3, 30, 400)  ,						dtype=np.uinta     )]

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

							return image_inputs




					def 						_SCREAMING_SNAKE_CASE						(	self						:     Optional[int]     ):
							lowerCAmelCase__        =   self.get_tokenizer()
							lowerCAmelCase__        =   self.get_rust_tokenizer()
							lowerCAmelCase__        =   self.get_image_processor()

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

							lowerCAmelCase__        =   OwlViTProcessor(tokenizer=UpperCamelCase_  ,						image_processor=UpperCamelCase_     )
							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  ,						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 						_SCREAMING_SNAKE_CASE						(	self						:     Tuple     ):
							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=UpperCamelCase_     )

							lowerCAmelCase__        =   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 						_SCREAMING_SNAKE_CASE						(	self						:     Optional[int]     ):
							lowerCAmelCase__        =   self.get_image_processor()
							lowerCAmelCase__        =   self.get_tokenizer()

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

							lowerCAmelCase__        =   self.prepare_image_inputs()

							lowerCAmelCase__        =   image_processor(UpperCamelCase_  ,						return_tensors="""np"""     )
							lowerCAmelCase__        =   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 						_SCREAMING_SNAKE_CASE						(	self						:     str     ):
							lowerCAmelCase__        =   self.get_image_processor()
							lowerCAmelCase__        =   self.get_tokenizer()

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

							lowerCAmelCase__        =   """lower newer"""

							lowerCAmelCase__        =   processor(text=UpperCamelCase_  ,						return_tensors="""np"""     )

							lowerCAmelCase__        =   tokenizer(UpperCamelCase_  ,						return_tensors="""np"""     )

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




					def 						_SCREAMING_SNAKE_CASE						(	self						:     Tuple     ):
							lowerCAmelCase__        =   self.get_image_processor()
							lowerCAmelCase__        =   self.get_tokenizer()

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

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

							lowerCAmelCase__        =   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 						_SCREAMING_SNAKE_CASE						(	self						:     Any     ):
							lowerCAmelCase__        =   """google/owlvit-base-patch32"""
							lowerCAmelCase__        =   OwlViTProcessor.from_pretrained(UpperCamelCase_     )

							lowerCAmelCase__        =   ["""cat""", """nasa badge"""]
							lowerCAmelCase__        =   processor(text=UpperCamelCase_     )

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




					def 						_SCREAMING_SNAKE_CASE						(	self						:     Optional[Any]     ):
							lowerCAmelCase__        =   """google/owlvit-base-patch32"""
							lowerCAmelCase__        =   OwlViTProcessor.from_pretrained(UpperCamelCase_     )

							lowerCAmelCase__        =   [["""cat""", """nasa badge"""], ["""person"""]]
							lowerCAmelCase__        =   processor(text=UpperCamelCase_     )

							lowerCAmelCase__        =   16
							lowerCAmelCase__        =   len(UpperCamelCase_     )
							lowerCAmelCase__        =   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 						_SCREAMING_SNAKE_CASE						(	self						:     str     ):
							lowerCAmelCase__        =   """google/owlvit-base-patch32"""
							lowerCAmelCase__        =   OwlViTProcessor.from_pretrained(UpperCamelCase_     )

							lowerCAmelCase__        =   ["""cat""", """nasa badge"""]
							lowerCAmelCase__        =   processor(text=UpperCamelCase_     )

							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 						_SCREAMING_SNAKE_CASE						(	self						:     Dict     ):
							lowerCAmelCase__        =   self.get_image_processor()
							lowerCAmelCase__        =   self.get_tokenizer()

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

							lowerCAmelCase__        =   self.prepare_image_inputs()
							lowerCAmelCase__        =   self.prepare_image_inputs()

							lowerCAmelCase__        =   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 						_SCREAMING_SNAKE_CASE						(	self						:     List[Any]     ):
							lowerCAmelCase__        =   self.get_image_processor()
							lowerCAmelCase__        =   self.get_tokenizer()

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

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

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

							self.assertListEqual(UpperCamelCase_  ,						UpperCamelCase_     )





"""simple docstring"""




def 							_UpperCAmelCase		(       lowerCamelCase__			,  lowerCamelCase__     ):





		"""simple docstring"""




		while b:
				lowerCAmelCase__   ,					lowerCAmelCase__        =   b, a % b
		return a







def 							_UpperCAmelCase		(       lowerCamelCase__			,  lowerCamelCase__     ):





		"""simple docstring"""




		return a if b == 0 else euclidean_gcd_recursive(lowerCamelCase__			,  a % b     )







def 							_UpperCAmelCase		(       ):





		"""simple docstring"""




		print(f"""euclidean_gcd(3, 5) = {euclidean_gcd(3			,  5     )}"""     )
		print(f"""euclidean_gcd(5, 3) = {euclidean_gcd(5			,  3     )}"""     )
		print(f"""euclidean_gcd(1, 3) = {euclidean_gcd(1			,  3     )}"""     )
		print(f"""euclidean_gcd(3, 6) = {euclidean_gcd(3			,  6     )}"""     )
		print(f"""euclidean_gcd(6, 3) = {euclidean_gcd(6			,  3     )}"""     )

		print(f"""euclidean_gcd_recursive(3, 5) = {euclidean_gcd_recursive(3			,  5     )}"""     )
		print(f"""euclidean_gcd_recursive(5, 3) = {euclidean_gcd_recursive(5			,  3     )}"""     )
		print(f"""euclidean_gcd_recursive(1, 3) = {euclidean_gcd_recursive(1			,  3     )}"""     )
		print(f"""euclidean_gcd_recursive(3, 6) = {euclidean_gcd_recursive(3			,  6     )}"""     )
		print(f"""euclidean_gcd_recursive(6, 3) = {euclidean_gcd_recursive(6			,  3     )}"""     )


if __name__ == "__main__":
			main()




