





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


							def   _snake_case	(				self     :Optional[Any]		) -> str:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   tempfile.mkdtemp()

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

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

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


							def   _snake_case	(				self     :Optional[Any]				,					**__A     :Optional[int]		) -> Union[str, Any]:



									"""simple docstring"""



									return CLIPTokenizer.from_pretrained(self.tmpdirname				,					**__A		)


							def   _snake_case	(				self     :Optional[int]				,					**__A     :List[str]		) -> Union[str, Any]:



									"""simple docstring"""



									return CLIPTokenizerFast.from_pretrained(self.tmpdirname				,					**__A		)


							def   _snake_case	(				self     :str				,					**__A     :Dict		) -> List[str]:



									"""simple docstring"""



									return CLIPImageProcessor.from_pretrained(self.tmpdirname				,					**__A		)


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



									"""simple docstring"""



									shutil.rmtree(self.tmpdirname		)


							def   _snake_case	(				self     :str		) -> List[Any]:



									"""simple docstring"""



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

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

									return image_inputs


							def   _snake_case	(				self     :Dict		) -> Optional[Any]:



									"""simple docstring"""



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

									SCREAMING_SNAKE_CASE__								=   CLIPProcessor(tokenizer=__A				,					image_processor=__A		)
									processor_slow.save_pretrained(self.tmpdirname		)
									SCREAMING_SNAKE_CASE__								=   CLIPProcessor.from_pretrained(self.tmpdirname				,					use_fast=__A		)

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

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


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



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   CLIPProcessor(tokenizer=self.get_tokenizer()				,					image_processor=self.get_image_processor()		)
									processor.save_pretrained(self.tmpdirname		)

									SCREAMING_SNAKE_CASE__								=   self.get_tokenizer(bos_token="""(BOS)"""				,					eos_token="""(EOS)"""		)
									SCREAMING_SNAKE_CASE__								=   self.get_image_processor(do_normalize=__A				,					padding_value=1.0		)

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

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

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


							def   _snake_case	(				self     :Any		) -> int:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   self.get_image_processor()
									SCREAMING_SNAKE_CASE__								=   self.get_tokenizer()

									SCREAMING_SNAKE_CASE__								=   CLIPProcessor(tokenizer=__A				,					image_processor=__A		)

									SCREAMING_SNAKE_CASE__								=   self.prepare_image_inputs()

									SCREAMING_SNAKE_CASE__								=   image_processor(__A				,					return_tensors="""np"""		)
									SCREAMING_SNAKE_CASE__								=   processor(images=__A				,					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   _snake_case	(				self     :Optional[Any]		) -> List[Any]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   self.get_image_processor()
									SCREAMING_SNAKE_CASE__								=   self.get_tokenizer()

									SCREAMING_SNAKE_CASE__								=   CLIPProcessor(tokenizer=__A				,					image_processor=__A		)

									SCREAMING_SNAKE_CASE__								=   """lower newer"""

									SCREAMING_SNAKE_CASE__								=   processor(text=__A		)

									SCREAMING_SNAKE_CASE__								=   tokenizer(__A		)

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


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



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   self.get_image_processor()
									SCREAMING_SNAKE_CASE__								=   self.get_tokenizer()

									SCREAMING_SNAKE_CASE__								=   CLIPProcessor(tokenizer=__A				,					image_processor=__A		)

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

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

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

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


							def   _snake_case	(				self     :List[Any]		) -> Dict:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   self.get_image_processor()
									SCREAMING_SNAKE_CASE__								=   self.get_tokenizer()

									SCREAMING_SNAKE_CASE__								=   CLIPProcessor(tokenizer=__A				,					image_processor=__A		)

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

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

									self.assertListEqual(__A				,					__A		)


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



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   self.get_image_processor()
									SCREAMING_SNAKE_CASE__								=   self.get_tokenizer()

									SCREAMING_SNAKE_CASE__								=   CLIPProcessor(tokenizer=__A				,					image_processor=__A		)

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

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

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






def 					SCREAMING_SNAKE_CASE__				(							UpperCamelCase__:				List[str]     ):
		SCREAMING_SNAKE_CASE__								=   len(UpperCamelCase__     )
		SCREAMING_SNAKE_CASE__								=   sum(UpperCamelCase__     )

		SCREAMING_SNAKE_CASE__								=   [[False for x in range(s + 1     )] for y in range(n + 1     )]

		for i in range(1       , n + 1     ):
				SCREAMING_SNAKE_CASE__								=   True

		for i in range(1       , s + 1     ):
				SCREAMING_SNAKE_CASE__								=   False

		for i in range(1       , n + 1     ):
				for j in range(1       , s + 1     ):
						SCREAMING_SNAKE_CASE__								=   dp[i][j - 1]

						if arr[i - 1] <= j:
								SCREAMING_SNAKE_CASE__								=   dp[i][j] or dp[i - 1][j - arr[i - 1]]

		for j in range(int(s / 2     )       , -1       , -1     ):
				if dp[n][j] is True:
						SCREAMING_SNAKE_CASE__								=   s - 2 * j
						break

		return diff