






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   __UpperCAmelCase  (				self		):
          UpperCAmelCase__      :  Tuple				      =			tempfile.mkdtemp()

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

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

          UpperCAmelCase__      :  Optional[Any]				      =			{
              """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],
          }
          UpperCAmelCase__      :  Tuple				      =			os.path.join(self.tmpdirname	,						_lowerCAmelCase		)
          with open(self.image_processor_file	,						"""w"""	,						encoding="""utf-8"""		) as fp:
               json.dump(_lowerCAmelCase	,						_lowerCAmelCase		)




     def   __UpperCAmelCase  (				self	,						**_lowerCAmelCase		):
          return CLIPTokenizer.from_pretrained(self.tmpdirname	,						**_lowerCAmelCase		)




     def   __UpperCAmelCase  (				self	,						**_lowerCAmelCase		):
          return CLIPTokenizerFast.from_pretrained(self.tmpdirname	,						**_lowerCAmelCase		)




     def   __UpperCAmelCase  (				self	,						**_lowerCAmelCase		):
          return CLIPImageProcessor.from_pretrained(self.tmpdirname	,						**_lowerCAmelCase		)




     def   __UpperCAmelCase  (				self		):
          shutil.rmtree(self.tmpdirname		)




     def   __UpperCAmelCase  (				self		):
          UpperCAmelCase__      :  Any				      =			[np.random.randint(255	,						size=(3, 30, 400)	,						dtype=np.uinta		)]

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

          return image_inputs




     def   __UpperCAmelCase  (				self		):
          UpperCAmelCase__      :  int				      =			self.get_tokenizer()
          UpperCAmelCase__      :  List[str]				      =			self.get_rust_tokenizer()
          UpperCAmelCase__      :  int				      =			self.get_image_processor()

          UpperCAmelCase__      :  Tuple				      =			CLIPProcessor(tokenizer=_lowerCAmelCase	,						image_processor=_lowerCAmelCase		)
          processor_slow.save_pretrained(self.tmpdirname		)
          UpperCAmelCase__      :  Optional[int]				      =			CLIPProcessor.from_pretrained(self.tmpdirname	,						use_fast=_lowerCAmelCase		)

          UpperCAmelCase__      :  Dict				      =			CLIPProcessor(tokenizer=_lowerCAmelCase	,						image_processor=_lowerCAmelCase		)
          processor_fast.save_pretrained(self.tmpdirname		)
          UpperCAmelCase__      :  Optional[Any]				      =			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	,						_lowerCAmelCase		)
          self.assertIsInstance(processor_fast.tokenizer	,						_lowerCAmelCase		)

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




     def   __UpperCAmelCase  (				self		):
          UpperCAmelCase__      :  Tuple				      =			CLIPProcessor(tokenizer=self.get_tokenizer()	,						image_processor=self.get_image_processor()		)
          processor.save_pretrained(self.tmpdirname		)

          UpperCAmelCase__      :  str				      =			self.get_tokenizer(bos_token="""(BOS)"""	,						eos_token="""(EOS)"""		)
          UpperCAmelCase__      :  str				      =			self.get_image_processor(do_normalize=_lowerCAmelCase	,						padding_value=1.0		)

          UpperCAmelCase__      :  str				      =			CLIPProcessor.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	,						_lowerCAmelCase		)

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




     def   __UpperCAmelCase  (				self		):
          UpperCAmelCase__      :  Any				      =			self.get_image_processor()
          UpperCAmelCase__      :  Tuple				      =			self.get_tokenizer()

          UpperCAmelCase__      :  str				      =			CLIPProcessor(tokenizer=_lowerCAmelCase	,						image_processor=_lowerCAmelCase		)

          UpperCAmelCase__      :  str				      =			self.prepare_image_inputs()

          UpperCAmelCase__      :  str				      =			image_processor(_lowerCAmelCase	,						return_tensors="""np"""		)
          UpperCAmelCase__      :  List[Any]				      =			processor(images=_lowerCAmelCase	,						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   __UpperCAmelCase  (				self		):
          UpperCAmelCase__      :  Union[str, Any]				      =			self.get_image_processor()
          UpperCAmelCase__      :  List[Any]				      =			self.get_tokenizer()

          UpperCAmelCase__      :  Optional[Any]				      =			CLIPProcessor(tokenizer=_lowerCAmelCase	,						image_processor=_lowerCAmelCase		)

          UpperCAmelCase__      :  Optional[int]				      =			"""lower newer"""

          UpperCAmelCase__      :  int				      =			processor(text=_lowerCAmelCase		)

          UpperCAmelCase__      :  Dict				      =			tokenizer(_lowerCAmelCase		)

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




     def   __UpperCAmelCase  (				self		):
          UpperCAmelCase__      :  Any				      =			self.get_image_processor()
          UpperCAmelCase__      :  Optional[Any]				      =			self.get_tokenizer()

          UpperCAmelCase__      :  List[Any]				      =			CLIPProcessor(tokenizer=_lowerCAmelCase	,						image_processor=_lowerCAmelCase		)

          UpperCAmelCase__      :  Optional[Any]				      =			"""lower newer"""
          UpperCAmelCase__      :  int				      =			self.prepare_image_inputs()

          UpperCAmelCase__      :  Optional[int]				      =			processor(text=_lowerCAmelCase	,						images=_lowerCAmelCase		)

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

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




     def   __UpperCAmelCase  (				self		):
          UpperCAmelCase__      :  int				      =			self.get_image_processor()
          UpperCAmelCase__      :  Any				      =			self.get_tokenizer()

          UpperCAmelCase__      :  Tuple				      =			CLIPProcessor(tokenizer=_lowerCAmelCase	,						image_processor=_lowerCAmelCase		)

          UpperCAmelCase__      :  Any				      =			[[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

          UpperCAmelCase__      :  Any				      =			processor.batch_decode(_lowerCAmelCase		)
          UpperCAmelCase__      :  List[Any]				      =			tokenizer.batch_decode(_lowerCAmelCase		)

          self.assertListEqual(_lowerCAmelCase	,						_lowerCAmelCase		)




     def   __UpperCAmelCase  (				self		):
          UpperCAmelCase__      :  Optional[Any]				      =			self.get_image_processor()
          UpperCAmelCase__      :  List[str]				      =			self.get_tokenizer()

          UpperCAmelCase__      :  Any				      =			CLIPProcessor(tokenizer=_lowerCAmelCase	,						image_processor=_lowerCAmelCase		)

          UpperCAmelCase__      :  str				      =			"""lower newer"""
          UpperCAmelCase__      :  Optional[Any]				      =			self.prepare_image_inputs()

          UpperCAmelCase__      :  List[Any]				      =			processor(text=_lowerCAmelCase	,						images=_lowerCAmelCase		)

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









def 	__a     (      A__			:  float			,  A__			:  float       ):
    if mass < 0:
        raise ValueError("The mass of a body cannot be negative"       )
    return 0.5 * mass * abs(A__       ) * abs(A__       )


if __name__ == "__main__":
    import doctest

    doctest.testmod(verbose=True)