




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 CLIPImageProcessor, CLIPProcessor

@require_vision
class 						__lowerCAmelCase      (      unittest.TestCase					):
							def  lowerCamelCase__				(		self		: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.48145466, 0.4578275, 0.40821073],
								    """image_std""": [0.26862954, 0.26130258, 0.27577711],
								}
								a									=				os.path.join(self.tmpdirname						, UpperCamelCase_							)
								with open(self.image_processor_file						, """w"""						, encoding="""utf-8"""							) as fp:
									json.dump(UpperCamelCase_						, UpperCamelCase_							)
							def  lowerCamelCase__				(		self		:str						, **__magic_name__		:List[str]							):







								'''simple docstring'''







								return CLIPTokenizer.from_pretrained(self.tmpdirname						, **UpperCamelCase_							)
							def  lowerCamelCase__				(		self		:Optional[Any]						, **__magic_name__		:Any							):







								'''simple docstring'''







								return CLIPTokenizerFast.from_pretrained(self.tmpdirname						, **UpperCamelCase_							)
							def  lowerCamelCase__				(		self		:Any						, **__magic_name__		:Optional[Any]							):







								'''simple docstring'''







								return CLIPImageProcessor.from_pretrained(self.tmpdirname						, **UpperCamelCase_							)
							def  lowerCamelCase__				(		self		:List[str]							):







								'''simple docstring'''







								shutil.rmtree(self.tmpdirname							)
							def  lowerCamelCase__				(		self		:List[str]							):







								'''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  lowerCamelCase__				(		self		:List[Any]							):







								'''simple docstring'''







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

								a									=				CLIPProcessor(tokenizer=UpperCamelCase_						, image_processor=UpperCamelCase_							)
								processor_slow.save_pretrained(self.tmpdirname							)
								a									=				CLIPProcessor.from_pretrained(self.tmpdirname						, use_fast=UpperCamelCase_							)

								a									=				CLIPProcessor(tokenizer=UpperCamelCase_						, image_processor=UpperCamelCase_							)
								processor_fast.save_pretrained(self.tmpdirname							)
								a									=				CLIPProcessor.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  lowerCamelCase__				(		self		:Dict							):







								'''simple docstring'''







								a									=				CLIPProcessor(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_						, padding_value=1.0							)

								a									=				CLIPProcessor.from_pretrained(
								    self.tmpdirname						, bos_token="""(BOS)"""						, eos_token="""(EOS)"""						, do_normalize=UpperCamelCase_						, padding_value=1.0							)

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







								'''simple docstring'''







								a									=				self.get_image_processor()
								a									=				self.get_tokenizer()

								a									=				CLIPProcessor(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  lowerCamelCase__				(		self		:Union[str, Any]							):







								'''simple docstring'''







								a									=				self.get_image_processor()
								a									=				self.get_tokenizer()

								a									=				CLIPProcessor(tokenizer=UpperCamelCase_						, image_processor=UpperCamelCase_							)

								a									=				"""lower newer"""

								a									=				processor(text=UpperCamelCase_							)

								a									=				tokenizer(UpperCamelCase_							)

								for key in encoded_tok.keys():
									self.assertListEqual(encoded_tok[key]						, encoded_processor[key]							)
							def  lowerCamelCase__				(		self		:Optional[int]							):







								'''simple docstring'''







								a									=				self.get_image_processor()
								a									=				self.get_tokenizer()

								a									=				CLIPProcessor(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  lowerCamelCase__				(		self		:str							):







								'''simple docstring'''







								a									=				self.get_image_processor()
								a									=				self.get_tokenizer()

								a									=				CLIPProcessor(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_							)





							def  lowerCamelCase__				(		self		:Dict							):







								'''simple docstring'''







								a									=				self.get_image_processor()
								a									=				self.get_tokenizer()

								a									=				CLIPProcessor(tokenizer=UpperCamelCase_						, image_processor=UpperCamelCase_							)

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

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

								self.assertListEqual(list(inputs.keys()							)						, processor.model_input_names							)









"""simple docstring"""
from maths.prime_check import is_prime


def 							A						(				__snake_case: int  )    ->		int:

       """simple docstring"""





       if not isinstance(__snake_case ,     __snake_case  ):
              __magic_name__      				=    F"""Input value of [number={number}] must be an integer"""
              raise TypeError(__snake_case  )
       if is_prime(__snake_case  ) and is_prime(number + 2  ):
              return number + 2
       else:
              return -1


if __name__ == "__main__":
 import doctest

 doctest.testmod()