






import os
import unittest

from transformers import MobileBertTokenizer, MobileBertTokenizerFast
from transformers.models.bert.tokenization_bert import (
    VOCAB_FILES_NAMES,
    BasicTokenizer,
    WordpieceTokenizer,
    _is_control,
    _is_punctuation,
    _is_whitespace,
)
from transformers.testing_utils import require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin, filter_non_english
@require_tokenizers
class     lowerCamelCase_					(   lowerCamelCase      ,					unittest.TestCase			):
				a__       							=	MobileBertTokenizer
				a__       							=	MobileBertTokenizerFast
				a__       							=	True
				a__       							=	True
				a__       							=	filter_non_english
				a__       							=	'''google/mobilebert-uncased'''







				def       A						(    self  ):
								"""simple docstring"""
								super().setUp()

								__magic_name__		:Tuple   =   [
								    '''[UNK]''',
								    '''[CLS]''',
								    '''[SEP]''',
								    '''[PAD]''',
								    '''[MASK]''',
								    '''want''',
								    '''##want''',
								    '''##ed''',
								    '''wa''',
								    '''un''',
								    '''runn''',
								    '''##ing''',
								    ''',''',
								    '''low''',
								    '''lowest''',
								]
								__magic_name__		:Dict   =   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]  )  )

								__magic_name__		:List[str]   =   [
								    (tokenizer_def[0], self.pre_trained_model_path, tokenizer_def[2])  # else the 'google/' prefix is stripped
								    for tokenizer_def in self.tokenizers_list
								]







				def       A						(    self							,       __lowerCAmelCase  ):
								"""simple docstring"""
								__magic_name__		:Union[str, Any]   =   '''UNwant\u00E9d,running'''
								__magic_name__		:int   =   '''unwanted, running'''
								return input_text, output_text







				def       A						(    self  ):
								"""simple docstring"""
								__magic_name__		:Optional[int]   =   self.tokenizer_class(self.vocab_file  )

								__magic_name__		:List[Any]   =   tokenizer.tokenize('''UNwant\u00E9d,running'''  )
								self.assertListEqual(__lowerCAmelCase							,       ['''un''', '''##want''', '''##ed''', ''',''', '''runn''', '''##ing''']  )
								self.assertListEqual(tokenizer.convert_tokens_to_ids(__lowerCAmelCase  )							,       [9, 6, 7, 1_2, 1_0, 1_1]  )







				def       A						(    self  ):
								"""simple docstring"""
								if not self.test_rust_tokenizer:
												return

								__magic_name__		:int   =   self.get_tokenizer()
								__magic_name__		:Tuple   =   self.get_rust_tokenizer()

								__magic_name__		:List[str]   =   '''UNwant\u00E9d,running'''

								__magic_name__		:Optional[Any]   =   tokenizer.tokenize(__lowerCAmelCase  )
								__magic_name__		:List[Any]   =   rust_tokenizer.tokenize(__lowerCAmelCase  )
								self.assertListEqual(__lowerCAmelCase							,       __lowerCAmelCase  )

								__magic_name__		:int   =   tokenizer.encode(__lowerCAmelCase							,       add_special_tokens=__lowerCAmelCase  )
								__magic_name__		:str   =   rust_tokenizer.encode(__lowerCAmelCase							,       add_special_tokens=__lowerCAmelCase  )
								self.assertListEqual(__lowerCAmelCase							,       __lowerCAmelCase  )

								__magic_name__		:List[Any]   =   self.get_rust_tokenizer()
								__magic_name__		:Any   =   tokenizer.encode(__lowerCAmelCase  )
								__magic_name__		:Any   =   rust_tokenizer.encode(__lowerCAmelCase  )
								self.assertListEqual(__lowerCAmelCase							,       __lowerCAmelCase  )

								# With lower casing
								__magic_name__		:Any   =   self.get_tokenizer(do_lower_case=__lowerCAmelCase  )
								__magic_name__		:List[Any]   =   self.get_rust_tokenizer(do_lower_case=__lowerCAmelCase  )

								__magic_name__		:Dict   =   '''UNwant\u00E9d,running'''

								__magic_name__		:Tuple   =   tokenizer.tokenize(__lowerCAmelCase  )
								__magic_name__		:Union[str, Any]   =   rust_tokenizer.tokenize(__lowerCAmelCase  )
								self.assertListEqual(__lowerCAmelCase							,       __lowerCAmelCase  )

								__magic_name__		:Optional[Any]   =   tokenizer.encode(__lowerCAmelCase							,       add_special_tokens=__lowerCAmelCase  )
								__magic_name__		:Dict   =   rust_tokenizer.encode(__lowerCAmelCase							,       add_special_tokens=__lowerCAmelCase  )
								self.assertListEqual(__lowerCAmelCase							,       __lowerCAmelCase  )

								__magic_name__		:Tuple   =   self.get_rust_tokenizer()
								__magic_name__		:Dict   =   tokenizer.encode(__lowerCAmelCase  )
								__magic_name__		:List[Any]   =   rust_tokenizer.encode(__lowerCAmelCase  )
								self.assertListEqual(__lowerCAmelCase							,       __lowerCAmelCase  )







				def       A						(    self  ):
								"""simple docstring"""
								__magic_name__		:Optional[int]   =   BasicTokenizer()

								self.assertListEqual(tokenizer.tokenize('''ah\u535A\u63A8zz'''  )							,       ['''ah''', '''\u535A''', '''\u63A8''', '''zz''']  )







				def       A						(    self  ):
								"""simple docstring"""
								__magic_name__		:List[Any]   =   BasicTokenizer(do_lower_case=__lowerCAmelCase  )

								self.assertListEqual(
								    tokenizer.tokenize(''' \tHeLLo!how  \n Are yoU?  '''  )							,       ['''hello''', '''!''', '''how''', '''are''', '''you''', '''?''']  )
								self.assertListEqual(tokenizer.tokenize('''H\u00E9llo'''  )							,       ['''hello''']  )







				def       A						(    self  ):
								"""simple docstring"""
								__magic_name__		:Union[str, Any]   =   BasicTokenizer(do_lower_case=__lowerCAmelCase							,       strip_accents=__lowerCAmelCase  )

								self.assertListEqual(
								    tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  '''  )							,       ['''hällo''', '''!''', '''how''', '''are''', '''you''', '''?''']  )
								self.assertListEqual(tokenizer.tokenize('''H\u00E9llo'''  )							,       ['''h\u00E9llo''']  )







				def       A						(    self  ):
								"""simple docstring"""
								__magic_name__		:Dict   =   BasicTokenizer(do_lower_case=__lowerCAmelCase							,       strip_accents=__lowerCAmelCase  )

								self.assertListEqual(
								    tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  '''  )							,       ['''hallo''', '''!''', '''how''', '''are''', '''you''', '''?''']  )
								self.assertListEqual(tokenizer.tokenize('''H\u00E9llo'''  )							,       ['''hello''']  )







				def       A						(    self  ):
								"""simple docstring"""
								__magic_name__		:Optional[int]   =   BasicTokenizer(do_lower_case=__lowerCAmelCase  )

								self.assertListEqual(
								    tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  '''  )							,       ['''hallo''', '''!''', '''how''', '''are''', '''you''', '''?''']  )
								self.assertListEqual(tokenizer.tokenize('''H\u00E9llo'''  )							,       ['''hello''']  )







				def       A						(    self  ):
								"""simple docstring"""
								__magic_name__		:List[str]   =   BasicTokenizer(do_lower_case=__lowerCAmelCase  )

								self.assertListEqual(
								    tokenizer.tokenize(''' \tHeLLo!how  \n Are yoU?  '''  )							,       ['''HeLLo''', '''!''', '''how''', '''Are''', '''yoU''', '''?''']  )







				def       A						(    self  ):
								"""simple docstring"""
								__magic_name__		:int   =   BasicTokenizer(do_lower_case=__lowerCAmelCase							,       strip_accents=__lowerCAmelCase  )

								self.assertListEqual(
								    tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  '''  )							,       ['''HäLLo''', '''!''', '''how''', '''Are''', '''yoU''', '''?''']  )







				def       A						(    self  ):
								"""simple docstring"""
								__magic_name__		:Optional[int]   =   BasicTokenizer(do_lower_case=__lowerCAmelCase							,       strip_accents=__lowerCAmelCase  )

								self.assertListEqual(
								    tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  '''  )							,       ['''HaLLo''', '''!''', '''how''', '''Are''', '''yoU''', '''?''']  )







				def       A						(    self  ):
								"""simple docstring"""
								__magic_name__		:Optional[Any]   =   BasicTokenizer(do_lower_case=__lowerCAmelCase							,       never_split=['''[UNK]''']  )

								self.assertListEqual(
								    tokenizer.tokenize(''' \tHeLLo!how  \n Are yoU? [UNK]'''  )							,       ['''HeLLo''', '''!''', '''how''', '''Are''', '''yoU''', '''?''', '''[UNK]''']  )







				def       A						(    self  ):
								"""simple docstring"""
								__magic_name__		:int   =   ['''[UNK]''', '''[CLS]''', '''[SEP]''', '''want''', '''##want''', '''##ed''', '''wa''', '''un''', '''runn''', '''##ing''']

								__magic_name__		:Union[str, Any]   =   {}
								for i, token in enumerate(__lowerCAmelCase  ):
												__magic_name__		:Tuple   =   i
								__magic_name__		:List[Any]   =   WordpieceTokenizer(vocab=__lowerCAmelCase							,       unk_token='''[UNK]'''  )

								self.assertListEqual(tokenizer.tokenize(''''''  )							,       []  )

								self.assertListEqual(tokenizer.tokenize('''unwanted running'''  )							,       ['''un''', '''##want''', '''##ed''', '''runn''', '''##ing''']  )

								self.assertListEqual(tokenizer.tokenize('''unwantedX running'''  )							,       ['''[UNK]''', '''runn''', '''##ing''']  )







				def       A						(    self  ):
								"""simple docstring"""
								self.assertTrue(_is_whitespace(''' '''  )  )
								self.assertTrue(_is_whitespace('''\t'''  )  )
								self.assertTrue(_is_whitespace('''\r'''  )  )
								self.assertTrue(_is_whitespace('''\n'''  )  )
								self.assertTrue(_is_whitespace('''\u00A0'''  )  )

								self.assertFalse(_is_whitespace('''A'''  )  )
								self.assertFalse(_is_whitespace('''-'''  )  )







				def       A						(    self  ):
								"""simple docstring"""
								self.assertTrue(_is_control('''\u0005'''  )  )

								self.assertFalse(_is_control('''A'''  )  )
								self.assertFalse(_is_control(''' '''  )  )
								self.assertFalse(_is_control('''\t'''  )  )
								self.assertFalse(_is_control('''\r'''  )  )







				def       A						(    self  ):
								"""simple docstring"""
								self.assertTrue(_is_punctuation('''-'''  )  )
								self.assertTrue(_is_punctuation('''$'''  )  )
								self.assertTrue(_is_punctuation('''`'''  )  )
								self.assertTrue(_is_punctuation('''.'''  )  )

								self.assertFalse(_is_punctuation('''A'''  )  )
								self.assertFalse(_is_punctuation(''' '''  )  )







				def       A						(    self  ):
								"""simple docstring"""
								__magic_name__		:Any   =   self.get_tokenizer()
								__magic_name__		:Any   =   self.get_rust_tokenizer()

								# Example taken from the issue https://github.com/huggingface/tokenizers/issues/340
								self.assertListEqual([tokenizer.tokenize(__lowerCAmelCase  ) for t in ['''Test''', '''\xad''', '''test''']]							,       [['''[UNK]'''], [], ['''[UNK]''']]  )

								self.assertListEqual(
								    [rust_tokenizer.tokenize(__lowerCAmelCase  ) for t in ['''Test''', '''\xad''', '''test''']]							,       [['''[UNK]'''], [], ['''[UNK]''']]  )







				@slow
				def       A						(    self  ):
								"""simple docstring"""
								__magic_name__		:Optional[int]   =   self.tokenizer_class.from_pretrained('''google/mobilebert-uncased'''  )

								__magic_name__		:Optional[int]   =   tokenizer.encode('''sequence builders'''							,       add_special_tokens=__lowerCAmelCase  )
								__magic_name__		:List[Any]   =   tokenizer.encode('''multi-sequence build'''							,       add_special_tokens=__lowerCAmelCase  )

								__magic_name__		:Union[str, Any]   =   tokenizer.build_inputs_with_special_tokens(__lowerCAmelCase  )
								__magic_name__		:List[Any]   =   tokenizer.build_inputs_with_special_tokens(__lowerCAmelCase							,       __lowerCAmelCase  )

								assert encoded_sentence == [1_0_1] + text + [1_0_2]
								assert encoded_pair == [1_0_1] + text + [1_0_2] + text_a + [1_0_2]







				def       A						(    self  ):
								"""simple docstring"""
								for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
												with self.subTest(F'''{tokenizer.__class__.__name__} ({pretrained_name})'''  ):
																__magic_name__		:Optional[Any]   =   self.rust_tokenizer_class.from_pretrained(__lowerCAmelCase							,       **__lowerCAmelCase  )

																__magic_name__		:Optional[int]   =   F'''A, naïve {tokenizer_r.mask_token} AllenNLP sentence.'''
																__magic_name__		:Optional[Any]   =   tokenizer_r.encode_plus(
																    __lowerCAmelCase							,       return_attention_mask=__lowerCAmelCase							,       return_token_type_ids=__lowerCAmelCase							,       return_offsets_mapping=__lowerCAmelCase							,       add_special_tokens=__lowerCAmelCase							,       )

																__magic_name__		:Any   =   tokenizer_r.do_lower_case if hasattr(__lowerCAmelCase							,       '''do_lower_case'''  ) else False
																__magic_name__		:Optional[int]   =   (
																    [
																        ((0, 0), tokenizer_r.cls_token),
																        ((0, 1), '''A'''),
																        ((1, 2), ''','''),
																        ((3, 5), '''na'''),
																        ((5, 6), '''##ï'''),
																        ((6, 8), '''##ve'''),
																        ((9, 1_5), tokenizer_r.mask_token),
																        ((1_6, 2_1), '''Allen'''),
																        ((2_1, 2_3), '''##NL'''),
																        ((2_3, 2_4), '''##P'''),
																        ((2_5, 3_3), '''sentence'''),
																        ((3_3, 3_4), '''.'''),
																        ((0, 0), tokenizer_r.sep_token),
																    ]
																    if not do_lower_case
																    else [
																        ((0, 0), tokenizer_r.cls_token),
																        ((0, 1), '''a'''),
																        ((1, 2), ''','''),
																        ((3, 8), '''naive'''),
																        ((9, 1_5), tokenizer_r.mask_token),
																        ((1_6, 2_1), '''allen'''),
																        ((2_1, 2_3), '''##nl'''),
																        ((2_3, 2_4), '''##p'''),
																        ((2_5, 3_3), '''sentence'''),
																        ((3_3, 3_4), '''.'''),
																        ((0, 0), tokenizer_r.sep_token),
																    ]
																)

																self.assertEqual(
																    [e[1] for e in expected_results]							,       tokenizer_r.convert_ids_to_tokens(tokens['''input_ids''']  )  )
																self.assertEqual([e[0] for e in expected_results]							,       tokens['''offset_mapping''']  )







				def       A						(    self  ):
								"""simple docstring"""
								__magic_name__		:Dict   =   ['''的''', '''人''', '''有''']
								__magic_name__		:Any   =   ''''''.join(__lowerCAmelCase  )
								for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
												with self.subTest(F'''{tokenizer.__class__.__name__} ({pretrained_name})'''  ):
																__magic_name__		:Optional[Any]   =   True
																__magic_name__		:Optional[int]   =   self.tokenizer_class.from_pretrained(__lowerCAmelCase							,       **__lowerCAmelCase  )
																__magic_name__		:Tuple   =   self.rust_tokenizer_class.from_pretrained(__lowerCAmelCase							,       **__lowerCAmelCase  )

																__magic_name__		:Dict   =   tokenizer_p.encode(__lowerCAmelCase							,       add_special_tokens=__lowerCAmelCase  )
																__magic_name__		:List[str]   =   tokenizer_r.encode(__lowerCAmelCase							,       add_special_tokens=__lowerCAmelCase  )

																__magic_name__		:Dict   =   tokenizer_r.convert_ids_to_tokens(__lowerCAmelCase  )
																__magic_name__		:Union[str, Any]   =   tokenizer_p.convert_ids_to_tokens(__lowerCAmelCase  )

																# it is expected that each Chinese character is not preceded by "##"
																self.assertListEqual(__lowerCAmelCase							,       __lowerCAmelCase  )
																self.assertListEqual(__lowerCAmelCase							,       __lowerCAmelCase  )

																__magic_name__		:List[str]   =   False
																__magic_name__		:Tuple   =   self.rust_tokenizer_class.from_pretrained(__lowerCAmelCase							,       **__lowerCAmelCase  )
																__magic_name__		:List[str]   =   self.tokenizer_class.from_pretrained(__lowerCAmelCase							,       **__lowerCAmelCase  )

																__magic_name__		:Optional[Any]   =   tokenizer_r.encode(__lowerCAmelCase							,       add_special_tokens=__lowerCAmelCase  )
																__magic_name__		:Union[str, Any]   =   tokenizer_p.encode(__lowerCAmelCase							,       add_special_tokens=__lowerCAmelCase  )

																__magic_name__		:List[str]   =   tokenizer_r.convert_ids_to_tokens(__lowerCAmelCase  )
																__magic_name__		:Optional[int]   =   tokenizer_p.convert_ids_to_tokens(__lowerCAmelCase  )

																# it is expected that only the first Chinese character is not preceded by "##".
																__magic_name__		:Dict   =   [
																    F'''##{token}''' if idx != 0 else token for idx, token in enumerate(__lowerCAmelCase  )
																]
																self.assertListEqual(__lowerCAmelCase							,       __lowerCAmelCase  )
																self.assertListEqual(__lowerCAmelCase							,       __lowerCAmelCase  )









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     __snake_case    (				unittest.TestCase  ):
       """simple docstring"""







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






              """simple docstring"""


              __snake_case       	=							tempfile.mkdtemp()

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

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

              __snake_case       	=							{
                  """do_resize""": True,
                  """size""": 20,
                  """do_center_crop""": True,
                  """crop_size""": 18,
                  """do_normalize""": True,
                  """image_mean""": [0.4814_5466, 0.457_8275, 0.4082_1073],
                  """image_std""": [0.2686_2954, 0.2613_0258, 0.2757_7711],
              }
              __snake_case       	=							os.path.join(self.tmpdirname      , _UpperCamelCase   )
              with open(self.image_processor_file      , """w"""      , encoding="""utf-8"""   ) as fp:
                     json.dump(_UpperCamelCase      , _UpperCamelCase   )


       def 			a		(		self      , **_UpperCamelCase   )      ->							Optional[int]:






              """simple docstring"""


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


       def 			a		(		self      , **_UpperCamelCase   )      ->							Union[str, Any]:






              """simple docstring"""


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


       def 			a		(		self      , **_UpperCamelCase   )      ->							List[str]:






              """simple docstring"""


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


       def 			a		(		self   )      ->							int:






              """simple docstring"""


              shutil.rmtree(self.tmpdirname   )


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






              """simple docstring"""


              __snake_case       	=							[np.random.randint(2_55      , size=(3, 30, 4_00)      , dtype=np.uinta   )]

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

              return image_inputs


       def 			a		(		self   )      ->							List[Any]:






              """simple docstring"""


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

              __snake_case       	=							CLIPProcessor(tokenizer=_UpperCamelCase      , image_processor=_UpperCamelCase   )
              processor_slow.save_pretrained(self.tmpdirname   )
              __snake_case       	=							CLIPProcessor.from_pretrained(self.tmpdirname      , use_fast=_UpperCamelCase   )

              __snake_case       	=							CLIPProcessor(tokenizer=_UpperCamelCase      , image_processor=_UpperCamelCase   )
              processor_fast.save_pretrained(self.tmpdirname   )
              __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      , _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 			a		(		self   )      ->							List[str]:






              """simple docstring"""


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

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

              __snake_case       	=							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 			a		(		self   )      ->							Any:






              """simple docstring"""


              __snake_case       	=							self.get_image_processor()
              __snake_case       	=							self.get_tokenizer()

              __snake_case       	=							CLIPProcessor(tokenizer=_UpperCamelCase      , image_processor=_UpperCamelCase   )

              __snake_case       	=							self.prepare_image_inputs()

              __snake_case       	=							image_processor(_UpperCamelCase      , return_tensors="""np"""   )
              __snake_case       	=							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 			a		(		self   )      ->							str:






              """simple docstring"""


              __snake_case       	=							self.get_image_processor()
              __snake_case       	=							self.get_tokenizer()

              __snake_case       	=							CLIPProcessor(tokenizer=_UpperCamelCase      , image_processor=_UpperCamelCase   )

              __snake_case       	=							"""lower newer"""

              __snake_case       	=							processor(text=_UpperCamelCase   )

              __snake_case       	=							tokenizer(_UpperCamelCase   )

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


       def 			a		(		self   )      ->							str:






              """simple docstring"""


              __snake_case       	=							self.get_image_processor()
              __snake_case       	=							self.get_tokenizer()

              __snake_case       	=							CLIPProcessor(tokenizer=_UpperCamelCase      , image_processor=_UpperCamelCase   )

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

              __snake_case       	=							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 			a		(		self   )      ->							Any:






              """simple docstring"""


              __snake_case       	=							self.get_image_processor()
              __snake_case       	=							self.get_tokenizer()

              __snake_case       	=							CLIPProcessor(tokenizer=_UpperCamelCase      , image_processor=_UpperCamelCase   )

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

              __snake_case       	=							processor.batch_decode(_UpperCamelCase   )
              __snake_case       	=							tokenizer.batch_decode(_UpperCamelCase   )

              self.assertListEqual(_UpperCamelCase      , _UpperCamelCase   )






       def 			a		(		self   )      ->							int:






              """simple docstring"""


              __snake_case       	=							self.get_image_processor()
              __snake_case       	=							self.get_tokenizer()

              __snake_case       	=							CLIPProcessor(tokenizer=_UpperCamelCase      , image_processor=_UpperCamelCase   )

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

              __snake_case       	=							processor(text=_UpperCamelCase      , images=_UpperCamelCase   )

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

