



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






					def     _a							(     self					:       Any					):






								"""simple docstring"""


								A__       =    tempfile.mkdtemp()

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

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

								A__       =    {
								    '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],
								}
								A__       =    os.path.join(self.tmpdirname				,					_snake_case					)
								with open(self.image_processor_file				,					'w'				,					encoding='utf-8'					) as fp:
											json.dump(_snake_case				,					_snake_case					)



					def     _a							(     self					:       Union[str, Any]				,					**_snake_case					:       Tuple					):






								"""simple docstring"""


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



					def     _a							(     self					:       Dict				,					**_snake_case					:       Union[str, Any]					):






								"""simple docstring"""


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



					def     _a							(     self					:       Optional[int]				,					**_snake_case					:       Union[str, Any]					):






								"""simple docstring"""


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



					def     _a							(     self					:       Dict					):






								"""simple docstring"""


								shutil.rmtree(self.tmpdirname					)



					def     _a							(     self					:       Union[str, Any]					):






								"""simple docstring"""


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

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

								return image_inputs



					def     _a							(     self					:       Optional[int]					):






								"""simple docstring"""


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

								A__       =    CLIPProcessor(tokenizer=_snake_case				,					image_processor=_snake_case					)
								processor_slow.save_pretrained(self.tmpdirname					)
								A__       =    CLIPProcessor.from_pretrained(self.tmpdirname				,					use_fast=_snake_case					)

								A__       =    CLIPProcessor(tokenizer=_snake_case				,					image_processor=_snake_case					)
								processor_fast.save_pretrained(self.tmpdirname					)
								A__       =    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				,					_snake_case					)
								self.assertIsInstance(processor_fast.tokenizer				,					_snake_case					)

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



					def     _a							(     self					:       List[str]					):






								"""simple docstring"""


								A__       =    CLIPProcessor(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=_snake_case				,					padding_value=1.0					)

								A__       =    CLIPProcessor.from_pretrained(
								    self.tmpdirname				,					bos_token='(BOS)'				,					eos_token='(EOS)'				,					do_normalize=_snake_case				,					padding_value=1.0					)

								self.assertEqual(processor.tokenizer.get_vocab()				,					tokenizer_add_kwargs.get_vocab()					)
								self.assertIsInstance(processor.tokenizer				,					_snake_case					)

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



					def     _a							(     self					:       int					):






								"""simple docstring"""


								A__       =    self.get_image_processor()
								A__       =    self.get_tokenizer()

								A__       =    CLIPProcessor(tokenizer=_snake_case				,					image_processor=_snake_case					)

								A__       =    self.prepare_image_inputs()

								A__       =    image_processor(_snake_case				,					return_tensors='np'					)
								A__       =    processor(images=_snake_case				,					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					:       Any					):






								"""simple docstring"""


								A__       =    self.get_image_processor()
								A__       =    self.get_tokenizer()

								A__       =    CLIPProcessor(tokenizer=_snake_case				,					image_processor=_snake_case					)

								A__       =    'lower newer'

								A__       =    processor(text=_snake_case					)

								A__       =    tokenizer(_snake_case					)

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



					def     _a							(     self					:       Union[str, Any]					):






								"""simple docstring"""


								A__       =    self.get_image_processor()
								A__       =    self.get_tokenizer()

								A__       =    CLIPProcessor(tokenizer=_snake_case				,					image_processor=_snake_case					)

								A__       =    'lower newer'
								A__       =    self.prepare_image_inputs()

								A__       =    processor(text=_snake_case				,					images=_snake_case					)

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

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



					def     _a							(     self					:       str					):






								"""simple docstring"""


								A__       =    self.get_image_processor()
								A__       =    self.get_tokenizer()

								A__       =    CLIPProcessor(tokenizer=_snake_case				,					image_processor=_snake_case					)

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

								A__       =    processor.batch_decode(_snake_case					)
								A__       =    tokenizer.batch_decode(_snake_case					)

								self.assertListEqual(_snake_case				,					_snake_case					)



					def     _a							(     self					:       Tuple					):






								"""simple docstring"""


								A__       =    self.get_image_processor()
								A__       =    self.get_tokenizer()

								A__       =    CLIPProcessor(tokenizer=_snake_case				,					image_processor=_snake_case					)

								A__       =    'lower newer'
								A__       =    self.prepare_image_inputs()

								A__       =    processor(text=_snake_case				,					images=_snake_case					)

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









from collections import OrderedDict
from typing import Mapping

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


SCREAMING_SNAKE_CASE__       =      logging.get_logger(__name__)

SCREAMING_SNAKE_CASE__       =      {
    '''roberta-base''': '''https://huggingface.co/roberta-base/resolve/main/config.json''',
    '''roberta-large''': '''https://huggingface.co/roberta-large/resolve/main/config.json''',
    '''roberta-large-mnli''': '''https://huggingface.co/roberta-large-mnli/resolve/main/config.json''',
    '''distilroberta-base''': '''https://huggingface.co/distilroberta-base/resolve/main/config.json''',
    '''roberta-base-openai-detector''': '''https://huggingface.co/roberta-base-openai-detector/resolve/main/config.json''',
    '''roberta-large-openai-detector''': '''https://huggingface.co/roberta-large-openai-detector/resolve/main/config.json''',
}


class      __lowerCAmelCase     (		UpperCAmelCase_      ):
					"""simple docstring"""






					A__				:		List[str]			       =    "roberta"



					def __init__(     self					:       List[str]				,					_snake_case					:       Union[str, Any]=5_02_65				,					_snake_case					:       List[Any]=7_68				,					_snake_case					:       List[str]=12				,					_snake_case					:       List[str]=12				,					_snake_case					:       Any=30_72				,					_snake_case					:       Union[str, Any]="gelu"				,					_snake_case					:       int=0.1				,					_snake_case					:       Union[str, Any]=0.1				,					_snake_case					:       Tuple=5_12				,					_snake_case					:       Union[str, Any]=2				,					_snake_case					:       Any=0.02				,					_snake_case					:       Any=1E-12				,					_snake_case					:       List[Any]=1				,					_snake_case					:       int=0				,					_snake_case					:       Any=2				,					_snake_case					:       Optional[Any]="absolute"				,					_snake_case					:       int=True				,					_snake_case					:       Any=None				,					**_snake_case					:       Any				,					):






								"""simple docstring"""


								super().__init__(pad_token_id=_snake_case				,					bos_token_id=_snake_case				,					eos_token_id=_snake_case				,					**_snake_case					)

								A__       =    vocab_size
								A__       =    hidden_size
								A__       =    num_hidden_layers
								A__       =    num_attention_heads
								A__       =    hidden_act
								A__       =    intermediate_size
								A__       =    hidden_dropout_prob
								A__       =    attention_probs_dropout_prob
								A__       =    max_position_embeddings
								A__       =    type_vocab_size
								A__       =    initializer_range
								A__       =    layer_norm_eps
								A__       =    position_embedding_type
								A__       =    use_cache
								A__       =    classifier_dropout







class      __lowerCAmelCase     (		UpperCAmelCase_      ):
					"""simple docstring"""






					@property
					def     _a							(     self					:       Dict					):






								"""simple docstring"""


								if self.task == "multiple-choice":
											A__       =    {0: 'batch', 1: 'choice', 2: 'sequence'}
								else:
											A__       =    {0: 'batch', 1: 'sequence'}
								return OrderedDict(
								    [
								        ('input_ids', dynamic_axis),
								        ('attention_mask', dynamic_axis),
								    ]					)




