


'''simple docstring'''



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   a__(	self    :				Any   )->  Optional[int]:

										"""simple docstring"""




										UpperCAmelCase         =			tempfile.mkdtemp()

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

										UpperCAmelCase         =			os.path.join(self.tmpdirname   ,					VOCAB_FILES_NAMES['''vocab_file''']   )
										UpperCAmelCase         =			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         =			{
										    '''do_resize''': True,
										    '''size''': 20,
										    '''do_center_crop''': True,
										    '''crop_size''': 18,
										    '''do_normalize''': True,
										    '''image_mean''': [0.48145466, 0.4578275, 0.40821073],
										    '''image_std''': [0.26862954, 0.26130258, 0.27577711],
										}
										UpperCAmelCase         =			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    :				Optional[int]   ,					**lowerCAmelCase    :				Optional[int]   )->  int:

										"""simple docstring"""




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




				def   a__(	self    :				str   ,					**lowerCAmelCase    :				Optional[int]   )->  Optional[Any]:

										"""simple docstring"""




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




				def   a__(	self    :				List[str]   ,					**lowerCAmelCase    :				Optional[int]   )->  Optional[Any]:

										"""simple docstring"""




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




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

										"""simple docstring"""




										shutil.rmtree(self.tmpdirname   )




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

										"""simple docstring"""




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

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

										return image_inputs




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

										"""simple docstring"""




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

										UpperCAmelCase         =			CLIPProcessor(tokenizer=lowerCAmelCase   ,					image_processor=lowerCAmelCase   )
										processor_slow.save_pretrained(self.tmpdirname   )
										UpperCAmelCase         =			CLIPProcessor.from_pretrained(self.tmpdirname   ,					use_fast=lowerCAmelCase   )

										UpperCAmelCase         =			CLIPProcessor(tokenizer=lowerCAmelCase   ,					image_processor=lowerCAmelCase   )
										processor_fast.save_pretrained(self.tmpdirname   )
										UpperCAmelCase         =			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   a__(	self    :				Optional[int]   )->  Any:

										"""simple docstring"""




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

										UpperCAmelCase         =			self.get_tokenizer(bos_token='''(BOS)'''   ,					eos_token='''(EOS)'''   )
										UpperCAmelCase         =			self.get_image_processor(do_normalize=lowerCAmelCase   ,					padding_value=1.0   )

										UpperCAmelCase         =			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   a__(	self    :				Union[str, Any]   )->  str:

										"""simple docstring"""




										UpperCAmelCase         =			self.get_image_processor()
										UpperCAmelCase         =			self.get_tokenizer()

										UpperCAmelCase         =			CLIPProcessor(tokenizer=lowerCAmelCase   ,					image_processor=lowerCAmelCase   )

										UpperCAmelCase         =			self.prepare_image_inputs()

										UpperCAmelCase         =			image_processor(lowerCAmelCase   ,					return_tensors='''np'''   )
										UpperCAmelCase         =			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   a__(	self    :				int   )->  List[Any]:

										"""simple docstring"""




										UpperCAmelCase         =			self.get_image_processor()
										UpperCAmelCase         =			self.get_tokenizer()

										UpperCAmelCase         =			CLIPProcessor(tokenizer=lowerCAmelCase   ,					image_processor=lowerCAmelCase   )

										UpperCAmelCase         =			'''lower newer'''

										UpperCAmelCase         =			processor(text=lowerCAmelCase   )

										UpperCAmelCase         =			tokenizer(lowerCAmelCase   )

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




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

										"""simple docstring"""




										UpperCAmelCase         =			self.get_image_processor()
										UpperCAmelCase         =			self.get_tokenizer()

										UpperCAmelCase         =			CLIPProcessor(tokenizer=lowerCAmelCase   ,					image_processor=lowerCAmelCase   )

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

										UpperCAmelCase         =			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   a__(	self    :				int   )->  int:

										"""simple docstring"""




										UpperCAmelCase         =			self.get_image_processor()
										UpperCAmelCase         =			self.get_tokenizer()

										UpperCAmelCase         =			CLIPProcessor(tokenizer=lowerCAmelCase   ,					image_processor=lowerCAmelCase   )

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

										UpperCAmelCase         =			processor.batch_decode(lowerCAmelCase   )
										UpperCAmelCase         =			tokenizer.batch_decode(lowerCAmelCase   )

										self.assertListEqual(lowerCAmelCase   ,					lowerCAmelCase   )





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

										"""simple docstring"""




										UpperCAmelCase         =			self.get_image_processor()
										UpperCAmelCase         =			self.get_tokenizer()

										UpperCAmelCase         =			CLIPProcessor(tokenizer=lowerCAmelCase   ,					image_processor=lowerCAmelCase   )

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

										UpperCAmelCase         =			processor(text=lowerCAmelCase   ,					images=lowerCAmelCase   )

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









'''simple docstring'''



from ...configuration_utils import PretrainedConfig
from ...utils import logging


_lowercase    :    Any			     =  logging.get_logger(__name__)

_lowercase    :    Dict			     =  {
    """facebook/dpr-ctx_encoder-single-nq-base""": (
        """https://huggingface.co/facebook/dpr-ctx_encoder-single-nq-base/resolve/main/config.json"""
    ),
    """facebook/dpr-question_encoder-single-nq-base""": (
        """https://huggingface.co/facebook/dpr-question_encoder-single-nq-base/resolve/main/config.json"""
    ),
    """facebook/dpr-reader-single-nq-base""": (
        """https://huggingface.co/facebook/dpr-reader-single-nq-base/resolve/main/config.json"""
    ),
    """facebook/dpr-ctx_encoder-multiset-base""": (
        """https://huggingface.co/facebook/dpr-ctx_encoder-multiset-base/resolve/main/config.json"""
    ),
    """facebook/dpr-question_encoder-multiset-base""": (
        """https://huggingface.co/facebook/dpr-question_encoder-multiset-base/resolve/main/config.json"""
    ),
    """facebook/dpr-reader-multiset-base""": (
        """https://huggingface.co/facebook/dpr-reader-multiset-base/resolve/main/config.json"""
    ),
}






class  UpperCamelCase__(     lowerCAmelCase ):
				__magic_name__       :   Optional[int]							= "dpr"




				def __init__(	self    :				Dict   ,					lowerCAmelCase    :				Any=30522   ,					lowerCAmelCase    :				List[str]=768   ,					lowerCAmelCase    :				Union[str, Any]=12   ,					lowerCAmelCase    :				Tuple=12   ,					lowerCAmelCase    :				Optional[int]=3072   ,					lowerCAmelCase    :				Optional[int]="gelu"   ,					lowerCAmelCase    :				Optional[Any]=0.1   ,					lowerCAmelCase    :				Any=0.1   ,					lowerCAmelCase    :				Optional[Any]=512   ,					lowerCAmelCase    :				List[Any]=2   ,					lowerCAmelCase    :				Tuple=0.02   ,					lowerCAmelCase    :				str=1E-12   ,					lowerCAmelCase    :				Optional[Any]=0   ,					lowerCAmelCase    :				Tuple="absolute"   ,					lowerCAmelCase    :				int = 0   ,					**lowerCAmelCase    :				Union[str, Any]   ,					)->  Optional[int]:

										"""simple docstring"""




										super().__init__(pad_token_id=lowerCAmelCase   ,					**lowerCAmelCase   )

										UpperCAmelCase         =			vocab_size
										UpperCAmelCase         =			hidden_size
										UpperCAmelCase         =			num_hidden_layers
										UpperCAmelCase         =			num_attention_heads
										UpperCAmelCase         =			hidden_act
										UpperCAmelCase         =			intermediate_size
										UpperCAmelCase         =			hidden_dropout_prob
										UpperCAmelCase         =			attention_probs_dropout_prob
										UpperCAmelCase         =			max_position_embeddings
										UpperCAmelCase         =			type_vocab_size
										UpperCAmelCase         =			initializer_range
										UpperCAmelCase         =			layer_norm_eps
										UpperCAmelCase         =			projection_dim
										UpperCAmelCase         =			position_embedding_type





