


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




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


										"""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.48_14_54_66, 0.4_57_82_75, 0.40_82_10_73],
										    '''image_std''': [0.26_86_29_54, 0.26_13_02_58, 0.27_57_77_11],
										}
										_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 							__UpperCamelCase				(       self					:      Union[str, Any]				,    **_a					:      Union[str, Any]  )							->     Union[str, Any]:


										"""simple docstring"""





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




						def 							__UpperCamelCase				(       self					:      Tuple				,    **_a					:      List[Any]  )							->     List[Any]:


										"""simple docstring"""





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




						def 							__UpperCamelCase				(       self					:      str				,    **_a					:      Union[str, Any]  )							->     Tuple:


										"""simple docstring"""





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




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


										"""simple docstring"""





										shutil.rmtree(self.tmpdirname  )




						def 							__UpperCamelCase				(       self					:      Optional[int]  )							->     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 							__UpperCamelCase				(       self					:      Optional[Any]  )							->     List[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 							__UpperCamelCase				(       self					:      Union[str, Any]  )							->     Union[str, 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 							__UpperCamelCase				(       self					:      Tuple  )							->     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			  =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 							__UpperCamelCase				(       self					:      Optional[int]  )							->     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			  ='''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 							__UpperCamelCase				(       self					:      Tuple  )							->     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()  )				,    ['''input_ids''', '''attention_mask''', '''pixel_values''']  )

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




						def 							__UpperCamelCase				(       self					:      Union[str, 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 							__UpperCamelCase				(       self					:      Optional[Any]  )							->     List[str]:


										"""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  )



from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_speech_available, is_torch_available


snake_case_						:			Optional[Any]													=							{
    '''configuration_audio_spectrogram_transformer''': [
        '''AUDIO_SPECTROGRAM_TRANSFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''ASTConfig''',
    ]
}

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							snake_case_						:			Optional[Any]													=							[
							    '''AUDIO_SPECTROGRAM_TRANSFORMER_PRETRAINED_MODEL_ARCHIVE_LIST''',
							    '''ASTForAudioClassification''',
							    '''ASTModel''',
							    '''ASTPreTrainedModel''',
							]

try:
							if not is_speech_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							snake_case_						:			List[Any]													=							['''ASTFeatureExtractor''']

if TYPE_CHECKING:
							from .configuration_audio_spectrogram_transformer import (
							    AUDIO_SPECTROGRAM_TRANSFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP,
							    ASTConfig,
							)

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_audio_spectrogram_transformer import (
														    AUDIO_SPECTROGRAM_TRANSFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
														    ASTForAudioClassification,
														    ASTModel,
														    ASTPreTrainedModel,
														)

							try:
														if not is_speech_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .feature_extraction_audio_spectrogram_transformer import ASTFeatureExtractor


else:
							import sys

							snake_case_						:			Optional[Any]													=							_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)