




import json
import os
import shutil
import tempfile
import unittest

import numpy as np

from transformers import BertTokenizerFast
from transformers.models.bert.tokenization_bert import VOCAB_FILES_NAMES, BertTokenizer
from transformers.testing_utils import require_tokenizers, require_vision
from transformers.utils import IMAGE_PROCESSOR_NAME, is_vision_available


if is_vision_available():
	from PIL import Image

	from transformers import VisionTextDualEncoderProcessor, ViTImageProcessor
@require_tokenizers
@require_vision
class        __snake_case  (unittest.TestCase		):



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





								'''simple docstring'''




								_lowerCAmelCase    :    Optional[int]										=      tempfile.mkdtemp()

								# fmt: off
								_lowerCAmelCase    :    int										=      ["""[UNK]""", """[CLS]""", """[SEP]""", """[PAD]""", """[MASK]""", """want""", """##want""", """##ed""", """wa""", """un""", """runn""", """##ing""", """,""", """low""", """lowest"""]
								# fmt: on
								_lowerCAmelCase    :    List[str]										=      os.path.join(self.tmpdirname		,	VOCAB_FILES_NAMES["""vocab_file"""]      )
								with open(self.vocab_file		,	"""w"""		,	encoding="""utf-8"""      ) as vocab_writer:
												vocab_writer.write("""""".join([x + """\n""" for x in vocab_tokens]      )      )

								_lowerCAmelCase    :    Optional[int]										=      {
								    """do_resize""": True,
								    """size""": {"""height""": 18, """width""": 18},
								    """do_normalize""": True,
								    """image_mean""": [0.5, 0.5, 0.5],
								    """image_std""": [0.5, 0.5, 0.5],
								}
								_lowerCAmelCase    :    Optional[Any]										=      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]		,	**_UpperCAmelCase      :		Optional[Any]      )  ->    List[Any]:





								'''simple docstring'''




								return BertTokenizer.from_pretrained(self.tmpdirname		,	**_UpperCAmelCase      )



				def       SCREAMING_SNAKE_CASE       (      self      :		List[Any]		,	**_UpperCAmelCase      :		Optional[Any]      )  ->    int:





								'''simple docstring'''




								return ViTImageProcessor.from_pretrained(self.tmpdirname		,	**_UpperCAmelCase      )



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





								'''simple docstring'''




								shutil.rmtree(self.tmpdirname      )



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





								'''simple docstring'''




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

								_lowerCAmelCase    :    Union[str, Any]										=      [Image.fromarray(np.moveaxis(_UpperCAmelCase		,	0		,	-1      )      ) for x in image_inputs]

								return image_inputs



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





								'''simple docstring'''




								_lowerCAmelCase    :    List[Any]										=      self.get_tokenizer()
								_lowerCAmelCase    :    Optional[Any]										=      self.get_image_processor()

								_lowerCAmelCase    :    Optional[Any]										=      VisionTextDualEncoderProcessor(tokenizer=_UpperCAmelCase		,	image_processor=_UpperCAmelCase      )

								processor.save_pretrained(self.tmpdirname      )
								_lowerCAmelCase    :    Optional[Any]										=      VisionTextDualEncoderProcessor.from_pretrained(self.tmpdirname      )

								self.assertEqual(processor.tokenizer.get_vocab()		,	tokenizer.get_vocab()      )
								self.assertIsInstance(processor.tokenizer		,	(BertTokenizer, BertTokenizerFast)      )

								self.assertEqual(processor.image_processor.to_json_string()		,	image_processor.to_json_string()      )
								self.assertIsInstance(processor.image_processor		,	_UpperCAmelCase      )



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





								'''simple docstring'''




								_lowerCAmelCase    :    Optional[Any]										=      VisionTextDualEncoderProcessor(
								    tokenizer=self.get_tokenizer()		,	image_processor=self.get_image_processor()      )
								processor.save_pretrained(self.tmpdirname      )

								_lowerCAmelCase    :    Union[str, Any]										=      self.get_tokenizer(bos_token="""(BOS)"""		,	eos_token="""(EOS)"""      )
								_lowerCAmelCase    :    List[Any]										=      self.get_image_processor(do_normalize=_UpperCAmelCase		,	padding_value=1.0      )

								_lowerCAmelCase    :    List[Any]										=      VisionTextDualEncoderProcessor.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		,	(BertTokenizer, BertTokenizerFast)      )

								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      :		List[Any]      )  ->    Tuple:





								'''simple docstring'''




								_lowerCAmelCase    :    List[str]										=      self.get_image_processor()
								_lowerCAmelCase    :    List[Any]										=      self.get_tokenizer()

								_lowerCAmelCase    :    str										=      VisionTextDualEncoderProcessor(tokenizer=_UpperCAmelCase		,	image_processor=_UpperCAmelCase      )

								_lowerCAmelCase    :    Optional[int]										=      self.prepare_image_inputs()

								_lowerCAmelCase    :    Optional[int]										=      image_processor(_UpperCAmelCase		,	return_tensors="""np"""      )
								_lowerCAmelCase    :    Tuple										=      processor(images=_UpperCAmelCase		,	return_tensors="""np"""      )

								for key in input_feat_extract.keys():
												self.assertAlmostEqual(input_feat_extract[key].sum()		,	input_processor[key].sum()		,	delta=1E-2      )



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





								'''simple docstring'''




								_lowerCAmelCase    :    int										=      self.get_image_processor()
								_lowerCAmelCase    :    Union[str, Any]										=      self.get_tokenizer()

								_lowerCAmelCase    :    List[Any]										=      VisionTextDualEncoderProcessor(tokenizer=_UpperCAmelCase		,	image_processor=_UpperCAmelCase      )

								_lowerCAmelCase    :    Tuple										=      """lower newer"""

								_lowerCAmelCase    :    Optional[Any]										=      processor(text=_UpperCAmelCase      )

								_lowerCAmelCase    :    int										=      tokenizer(_UpperCAmelCase      )

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



				def       SCREAMING_SNAKE_CASE       (      self      :		Dict      )  ->    str:





								'''simple docstring'''




								_lowerCAmelCase    :    Tuple										=      self.get_image_processor()
								_lowerCAmelCase    :    str										=      self.get_tokenizer()

								_lowerCAmelCase    :    List[str]										=      VisionTextDualEncoderProcessor(tokenizer=_UpperCAmelCase		,	image_processor=_UpperCAmelCase      )

								_lowerCAmelCase    :    str										=      """lower newer"""
								_lowerCAmelCase    :    Dict										=      self.prepare_image_inputs()

								_lowerCAmelCase    :    int										=      processor(text=_UpperCAmelCase		,	images=_UpperCAmelCase      )

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

								# test if it raises when no input is passed
								with self.assertRaises(_UpperCAmelCase      ):
												processor()



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





								'''simple docstring'''




								_lowerCAmelCase    :    Any										=      self.get_image_processor()
								_lowerCAmelCase    :    List[Any]										=      self.get_tokenizer()

								_lowerCAmelCase    :    Optional[int]										=      VisionTextDualEncoderProcessor(tokenizer=_UpperCAmelCase		,	image_processor=_UpperCAmelCase      )

								_lowerCAmelCase    :    Optional[int]										=      [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

								_lowerCAmelCase    :    Dict										=      processor.batch_decode(_UpperCAmelCase      )
								_lowerCAmelCase    :    int										=      tokenizer.batch_decode(_UpperCAmelCase      )

								self.assertListEqual(_UpperCAmelCase		,	_UpperCAmelCase      )



				def       SCREAMING_SNAKE_CASE       (      self      :		List[str]      )  ->    Tuple:





								'''simple docstring'''




								_lowerCAmelCase    :    str										=      self.get_image_processor()
								_lowerCAmelCase    :    Any										=      self.get_tokenizer()

								_lowerCAmelCase    :    Optional[int]										=      VisionTextDualEncoderProcessor(tokenizer=_UpperCAmelCase		,	image_processor=_UpperCAmelCase      )

								_lowerCAmelCase    :    str										=      """lower newer"""
								_lowerCAmelCase    :    Tuple										=      self.prepare_image_inputs()

								_lowerCAmelCase    :    Any										=      processor(text=_UpperCAmelCase		,	images=_UpperCAmelCase      )

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







from math import loga




def 							_UpperCAmelCase  (UpperCamelCase_ : int       ):
				'''simple docstring'''
				if a < 0:
								raise ValueError("""Input value must be a positive integer"""       )
				elif isinstance(UpperCamelCase_      ,    UpperCamelCase_       ):
								raise TypeError("""Input value must be a 'int' type"""       )
				return 0 if (a == 0) else int(loga(a & -a       )       )


if __name__ == "__main__":
	import doctest

	doctest.testmod()

