



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

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


    """simple docstring"""






    a						=		tempfile.mkdtemp()

    # fmt: off
    a						=		["[UNK]", "[CLS]", "[SEP]", "[PAD]", "[MASK]", "want", "##want", "##ed", "wa", "un", "runn", "##ing", ",", "low", "lowest"]
    # fmt: on
    a						=		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]							)							)

    a						=		{
        "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],
    }
    a						=		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			:       Dict							,   **__lowerCAmelCase			:       Any							)       ->				Tuple:


    """simple docstring"""






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

   def 		A							(      self			:       List[Any]							,   **__lowerCAmelCase			:       str							)       ->				Union[str, Any]:


    """simple docstring"""






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

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


    """simple docstring"""






    shutil.rmtree(self.tmpdirname							)

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


    """simple docstring"""






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

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

    return image_inputs

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


    """simple docstring"""






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

    a						=		VisionTextDualEncoderProcessor(tokenizer=__lowerCAmelCase							,   image_processor=__lowerCAmelCase							)

    processor.save_pretrained(self.tmpdirname							)
    a						=		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							,   __lowerCAmelCase							)

   def 		A							(      self			:       Dict							)       ->				Dict:


    """simple docstring"""






    a						=		VisionTextDualEncoderProcessor(
        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=__lowerCAmelCase							,   padding_value=1.0							)

    a						=		VisionTextDualEncoderProcessor.from_pretrained(
        self.tmpdirname							,   bos_token="(BOS)"							,   eos_token="(EOS)"							,   do_normalize=__lowerCAmelCase							,   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							,   __lowerCAmelCase							)

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


    """simple docstring"""






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

    a						=		VisionTextDualEncoderProcessor(tokenizer=__lowerCAmelCase							,   image_processor=__lowerCAmelCase							)

    a						=		self.prepare_image_inputs()

    a						=		image_processor(__lowerCAmelCase							,   return_tensors="np"							)
    a						=		processor(images=__lowerCAmelCase							,   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 		A							(      self			:       Optional[Any]							)       ->				Optional[int]:


    """simple docstring"""






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

    a						=		VisionTextDualEncoderProcessor(tokenizer=__lowerCAmelCase							,   image_processor=__lowerCAmelCase							)

    a						=		"lower newer"

    a						=		processor(text=__lowerCAmelCase							)

    a						=		tokenizer(__lowerCAmelCase							)

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

   def 		A							(      self			:       str							)       ->				str:


    """simple docstring"""






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

    a						=		VisionTextDualEncoderProcessor(tokenizer=__lowerCAmelCase							,   image_processor=__lowerCAmelCase							)

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

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

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

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


    """simple docstring"""






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

    a						=		VisionTextDualEncoderProcessor(tokenizer=__lowerCAmelCase							,   image_processor=__lowerCAmelCase							)

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

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

    self.assertListEqual(__lowerCAmelCase							,   __lowerCAmelCase							)




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


    """simple docstring"""






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

    a						=		VisionTextDualEncoderProcessor(tokenizer=__lowerCAmelCase							,   image_processor=__lowerCAmelCase							)

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

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

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






def 	UpperCAmelCase__      (      UpperCAmelCase__ :int ,					UpperCAmelCase__ :int					):






 '''simple docstring'''

 if a < 0 or b < 0:
  raise ValueError("the value of both inputs must be positive"					)

 a						=		str(bin(UpperCAmelCase__					)					)[2:]  # remove the leading "0b"
 a						=		str(bin(UpperCAmelCase__					)					)[2:]  # remove the leading "0b"

 a						=		max(len(UpperCAmelCase__					) ,					len(UpperCAmelCase__					)					)

 return "0b" + "".join(
     str(int(char_a == "1" and char_b == "1"					)					)
     for char_a, char_b in zip(a_binary.zfill(UpperCAmelCase__					) ,					b_binary.zfill(UpperCAmelCase__					)					)					)


if __name__ == "__main__":
     import doctest

     doctest.testmod()

