


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 OwlViTImageProcessor, OwlViTProcessor
@require_vision
class        _lowercase      (			unittest.TestCase       ):






				'''simple docstring'''



				def 		__magic_name__(       self			:List[str]	)		->			int:
										__SCREAMING_SNAKE_CASE						:     int					=		tempfile.mkdtemp()

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

										__SCREAMING_SNAKE_CASE						:     Optional[Any]					=		os.path.join(self.tmpdirname			,			VOCAB_FILES_NAMES['''vocab_file''']	)
										__SCREAMING_SNAKE_CASE						:     Tuple					=		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__	)	)

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


				def 		__magic_name__(       self			:List[Any]			,			**lowerCAmelCase__			:Dict	)		->			Dict:
										return CLIPTokenizer.from_pretrained(self.tmpdirname			,			pad_token='''!'''			,			**lowerCAmelCase__	)


				def 		__magic_name__(       self			:Union[str, Any]			,			**lowerCAmelCase__			:Any	)		->			str:
										return CLIPTokenizerFast.from_pretrained(self.tmpdirname			,			pad_token='''!'''			,			**lowerCAmelCase__	)


				def 		__magic_name__(       self			:Optional[Any]			,			**lowerCAmelCase__			:int	)		->			Optional[int]:
										return OwlViTImageProcessor.from_pretrained(self.tmpdirname			,			**lowerCAmelCase__	)


				def 		__magic_name__(       self			:Tuple	)		->			str:
										shutil.rmtree(self.tmpdirname	)


				def 		__magic_name__(       self			:Optional[int]	)		->			Any:
										__SCREAMING_SNAKE_CASE						:     int					=		[np.random.randint(255			,			size=(3, 30, 400)			,			dtype=np.uinta	)]

										__SCREAMING_SNAKE_CASE						:     int					=		[Image.fromarray(np.moveaxis(lowerCAmelCase__			,			0			,			-1	)	) for x in image_inputs]

										return image_inputs


				def 		__magic_name__(       self			:List[str]	)		->			int:
										__SCREAMING_SNAKE_CASE						:     int					=		self.get_tokenizer()
										__SCREAMING_SNAKE_CASE						:     Tuple					=		self.get_rust_tokenizer()
										__SCREAMING_SNAKE_CASE						:     List[str]					=		self.get_image_processor()

										__SCREAMING_SNAKE_CASE						:     str					=		OwlViTProcessor(tokenizer=lowerCAmelCase__			,			image_processor=lowerCAmelCase__	)
										processor_slow.save_pretrained(self.tmpdirname	)
										__SCREAMING_SNAKE_CASE						:     Union[str, Any]					=		OwlViTProcessor.from_pretrained(self.tmpdirname			,			use_fast=lowerCAmelCase__	)

										__SCREAMING_SNAKE_CASE						:     List[str]					=		OwlViTProcessor(tokenizer=lowerCAmelCase__			,			image_processor=lowerCAmelCase__	)
										processor_fast.save_pretrained(self.tmpdirname	)
										__SCREAMING_SNAKE_CASE						:     List[Any]					=		OwlViTProcessor.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 		__magic_name__(       self			:Optional[Any]	)		->			Tuple:
										__SCREAMING_SNAKE_CASE						:     Optional[Any]					=		OwlViTProcessor(tokenizer=self.get_tokenizer()			,			image_processor=self.get_image_processor()	)
										processor.save_pretrained(self.tmpdirname	)

										__SCREAMING_SNAKE_CASE						:     Any					=		self.get_tokenizer(bos_token='''(BOS)'''			,			eos_token='''(EOS)'''	)
										__SCREAMING_SNAKE_CASE						:     int					=		self.get_image_processor(do_normalize=lowerCAmelCase__	)

										__SCREAMING_SNAKE_CASE						:     str					=		OwlViTProcessor.from_pretrained(
										    self.tmpdirname			,			bos_token='''(BOS)'''			,			eos_token='''(EOS)'''			,			do_normalize=lowerCAmelCase__	)

										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 		__magic_name__(       self			:Union[str, Any]	)		->			Union[str, Any]:
										__SCREAMING_SNAKE_CASE						:     Optional[Any]					=		self.get_image_processor()
										__SCREAMING_SNAKE_CASE						:     Any					=		self.get_tokenizer()

										__SCREAMING_SNAKE_CASE						:     Dict					=		OwlViTProcessor(tokenizer=lowerCAmelCase__			,			image_processor=lowerCAmelCase__	)

										__SCREAMING_SNAKE_CASE						:     Union[str, Any]					=		self.prepare_image_inputs()

										__SCREAMING_SNAKE_CASE						:     Tuple					=		image_processor(lowerCAmelCase__			,			return_tensors='''np'''	)
										__SCREAMING_SNAKE_CASE						:     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 		__magic_name__(       self			:Union[str, Any]	)		->			Union[str, Any]:
										__SCREAMING_SNAKE_CASE						:     Dict					=		self.get_image_processor()
										__SCREAMING_SNAKE_CASE						:     Any					=		self.get_tokenizer()

										__SCREAMING_SNAKE_CASE						:     Dict					=		OwlViTProcessor(tokenizer=lowerCAmelCase__			,			image_processor=lowerCAmelCase__	)

										__SCREAMING_SNAKE_CASE						:     Optional[int]					=		'''lower newer'''

										__SCREAMING_SNAKE_CASE						:     Dict					=		processor(text=lowerCAmelCase__			,			return_tensors='''np'''	)

										__SCREAMING_SNAKE_CASE						:     Optional[int]					=		tokenizer(lowerCAmelCase__			,			return_tensors='''np'''	)

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


				def 		__magic_name__(       self			:str	)		->			str:
										__SCREAMING_SNAKE_CASE						:     Tuple					=		self.get_image_processor()
										__SCREAMING_SNAKE_CASE						:     Tuple					=		self.get_tokenizer()

										__SCREAMING_SNAKE_CASE						:     Union[str, Any]					=		OwlViTProcessor(tokenizer=lowerCAmelCase__			,			image_processor=lowerCAmelCase__	)

										__SCREAMING_SNAKE_CASE						:     Optional[Any]					=		'''lower newer'''
										__SCREAMING_SNAKE_CASE						:     Any					=		self.prepare_image_inputs()

										__SCREAMING_SNAKE_CASE						:     List[Any]					=		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 		__magic_name__(       self			:Any	)		->			Tuple:
										__SCREAMING_SNAKE_CASE						:     Optional[Any]					=		'''google/owlvit-base-patch32'''
										__SCREAMING_SNAKE_CASE						:     str					=		OwlViTProcessor.from_pretrained(lowerCAmelCase__	)

										__SCREAMING_SNAKE_CASE						:     Optional[int]					=		['''cat''', '''nasa badge''']
										__SCREAMING_SNAKE_CASE						:     Dict					=		processor(text=lowerCAmelCase__	)

										__SCREAMING_SNAKE_CASE						:     Optional[Any]					=		16
										self.assertListEqual(list(inputs.keys()	)			,			['''input_ids''', '''attention_mask''']	)
										self.assertEqual(inputs['''input_ids'''].shape			,			(2, seq_length)	)

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


				def 		__magic_name__(       self			:List[str]	)		->			Optional[int]:
										__SCREAMING_SNAKE_CASE						:     Optional[int]					=		'''google/owlvit-base-patch32'''
										__SCREAMING_SNAKE_CASE						:     Dict					=		OwlViTProcessor.from_pretrained(lowerCAmelCase__	)

										__SCREAMING_SNAKE_CASE						:     Any					=		[['''cat''', '''nasa badge'''], ['''person''']]
										__SCREAMING_SNAKE_CASE						:     Optional[int]					=		processor(text=lowerCAmelCase__	)

										__SCREAMING_SNAKE_CASE						:     List[Any]					=		16
										__SCREAMING_SNAKE_CASE						:     List[str]					=		len(lowerCAmelCase__	)
										__SCREAMING_SNAKE_CASE						:     Dict					=		max([len(lowerCAmelCase__	) for texts in input_texts]	)

										self.assertListEqual(list(inputs.keys()	)			,			['''input_ids''', '''attention_mask''']	)
										self.assertEqual(inputs['''input_ids'''].shape			,			(batch_size * num_max_text_queries, seq_length)	)

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


				def 		__magic_name__(       self			:Tuple	)		->			List[Any]:
										__SCREAMING_SNAKE_CASE						:     Dict					=		'''google/owlvit-base-patch32'''
										__SCREAMING_SNAKE_CASE						:     Any					=		OwlViTProcessor.from_pretrained(lowerCAmelCase__	)

										__SCREAMING_SNAKE_CASE						:     Any					=		['''cat''', '''nasa badge''']
										__SCREAMING_SNAKE_CASE						:     Union[str, Any]					=		processor(text=lowerCAmelCase__	)

										__SCREAMING_SNAKE_CASE						:     str					=		16
										__SCREAMING_SNAKE_CASE						:     List[str]					=		inputs['''input_ids''']
										__SCREAMING_SNAKE_CASE						:     Union[str, Any]					=		[
										    [49_406, 2_368, 49_407, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
										    [49_406, 6_841, 11_301, 49_407, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
										]

										self.assertListEqual(list(inputs.keys()	)			,			['''input_ids''', '''attention_mask''']	)
										self.assertEqual(inputs['''input_ids'''].shape			,			(2, seq_length)	)
										self.assertListEqual(list(input_ids[0]	)			,			predicted_ids[0]	)
										self.assertListEqual(list(input_ids[1]	)			,			predicted_ids[1]	)


				def 		__magic_name__(       self			:str	)		->			str:
										__SCREAMING_SNAKE_CASE						:     Any					=		self.get_image_processor()
										__SCREAMING_SNAKE_CASE						:     List[str]					=		self.get_tokenizer()

										__SCREAMING_SNAKE_CASE						:     Any					=		OwlViTProcessor(tokenizer=lowerCAmelCase__			,			image_processor=lowerCAmelCase__	)

										__SCREAMING_SNAKE_CASE						:     Optional[Any]					=		self.prepare_image_inputs()
										__SCREAMING_SNAKE_CASE						:     Optional[Any]					=		self.prepare_image_inputs()

										__SCREAMING_SNAKE_CASE						:     int					=		processor(images=lowerCAmelCase__			,			query_images=lowerCAmelCase__	)

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

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



				def 		__magic_name__(       self			:Optional[Any]	)		->			Tuple:
										__SCREAMING_SNAKE_CASE						:     Union[str, Any]					=		self.get_image_processor()
										__SCREAMING_SNAKE_CASE						:     List[Any]					=		self.get_tokenizer()

										__SCREAMING_SNAKE_CASE						:     List[str]					=		OwlViTProcessor(tokenizer=lowerCAmelCase__			,			image_processor=lowerCAmelCase__	)

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

										__SCREAMING_SNAKE_CASE						:     str					=		processor.batch_decode(lowerCAmelCase__	)
										__SCREAMING_SNAKE_CASE						:     List[Any]					=		tokenizer.batch_decode(lowerCAmelCase__	)

										self.assertListEqual(lowerCAmelCase__			,			lowerCAmelCase__	)




import numpy as np
from scipy.spatial.distance import cdist
from sklearn.metrics import fa_score

import datasets


__lowerCAmelCase	: Optional[int]  				='\\n    @inproceedings{kakwani2020indicnlpsuite,\n    title={{IndicNLPSuite: Monolingual Corpora, Evaluation Benchmarks and Pre-trained Multilingual Language Models for Indian Languages}},\n    author={Divyanshu Kakwani and Anoop Kunchukuttan and Satish Golla and Gokul N.C. and Avik Bhattacharyya and Mitesh M. Khapra and Pratyush Kumar},\n    year={2020},\n    booktitle={Findings of EMNLP},\n}\n'

__lowerCAmelCase	: Optional[Any]  				='\\n    IndicGLUE is a natural language understanding benchmark for Indian languages. It contains a wide\n    variety of tasks and covers 11 major Indian languages - as, bn, gu, hi, kn, ml, mr, or, pa, ta, te.\n'

__lowerCAmelCase	: Dict  				='\nCompute IndicGLUE evaluation metric associated to each IndicGLUE dataset.\nArgs:\n    predictions: list of predictions to score (as int64),\n        except for \'cvit-mkb-clsr\' where each prediction is a vector (of float32).\n    references: list of ground truth labels corresponding to the predictions (as int64),\n        except for \'cvit-mkb-clsr\' where each reference is a vector (of float32).\nReturns: depending on the IndicGLUE subset, one or several of:\n    "accuracy": Accuracy\n    "f1": F1 score\n    "precision": Precision@10\nExamples:\n\n    >>> indic_glue_metric = datasets.load_metric(\'indic_glue\', \'wnli\')  # \'wnli\' or any of ["copa", "sna", "csqa", "wstp", "inltkh", "bbca", "iitp-mr", "iitp-pr", "actsa-sc", "md"]\n    >>> references = [0, 1]\n    >>> predictions = [0, 1]\n    >>> results = indic_glue_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {\'accuracy\': 1.0}\n\n    >>> indic_glue_metric = datasets.load_metric(\'indic_glue\', \'wiki-ner\')\n    >>> references = [0, 1]\n    >>> predictions = [0, 1]\n    >>> results = indic_glue_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {\'accuracy\': 1.0, \'f1\': 1.0}\n\n    >>> indic_glue_metric = datasets.load_metric(\'indic_glue\', \'cvit-mkb-clsr\')\n    >>> references = [[0.5, 0.5, 0.5], [0.1, 0.2, 0.3]]\n    >>> predictions = [[0.5, 0.5, 0.5], [0.1, 0.2, 0.3]]\n    >>> results = indic_glue_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {\'precision@10\': 1.0}\n\n'


def        _UpperCamelCase							(      lowercase__    ,       lowercase__      ):
						return float((preds == labels).mean()      )


def        _UpperCamelCase							(      lowercase__    ,       lowercase__      ):
						__SCREAMING_SNAKE_CASE						:     Optional[Any]					=		simple_accuracy(lowercase__    ,       lowercase__      )
						__SCREAMING_SNAKE_CASE						:     List[str]					=		float(fa_score(y_true=lowercase__    ,       y_pred=lowercase__      )      )
						return {
						    "accuracy": acc,
						    "f1": fa,
						}


def        _UpperCamelCase							(      lowercase__    ,       lowercase__      ):
						__SCREAMING_SNAKE_CASE						:     Optional[int]					=		np.array(lowercase__      )
						__SCREAMING_SNAKE_CASE						:     str					=		np.array(lowercase__      )
						__SCREAMING_SNAKE_CASE						:     str					=		en_sentvecs.shape[0]

						# mean centering
						__SCREAMING_SNAKE_CASE						:     Tuple					=		en_sentvecs - np.mean(lowercase__    ,       axis=0      )
						__SCREAMING_SNAKE_CASE						:     Optional[int]					=		in_sentvecs - np.mean(lowercase__    ,       axis=0      )

						__SCREAMING_SNAKE_CASE						:     str					=		cdist(lowercase__    ,       lowercase__    ,       '''cosine'''      )
						__SCREAMING_SNAKE_CASE						:     int					=		np.array(range(lowercase__      )      )
						__SCREAMING_SNAKE_CASE						:     Optional[Any]					=		sim.argsort(axis=1      )[:, :10]
						__SCREAMING_SNAKE_CASE						:     str					=		np.any(preds == actual[:, None]    ,       axis=1      )
						return float(matches.mean()      )
@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION						,			_KWARGS_DESCRIPTION       )
class        _lowercase      (			datasets.Metric       ):






				'''simple docstring'''



				def 		__magic_name__(       self			:Tuple	)		->			Tuple:
										if self.config_name not in [
										    "wnli",
										    "copa",
										    "sna",
										    "csqa",
										    "wstp",
										    "inltkh",
										    "bbca",
										    "cvit-mkb-clsr",
										    "iitp-mr",
										    "iitp-pr",
										    "actsa-sc",
										    "md",
										    "wiki-ner",
										]:
																raise KeyError(
																    '''You should supply a configuration name selected in '''
																    '''["wnli", "copa", "sna", "csqa", "wstp", "inltkh", "bbca", '''
																    '''"cvit-mkb-clsr", "iitp-mr", "iitp-pr", "actsa-sc", "md", '''
																    '''"wiki-ner"]'''	)
										return datasets.MetricInfo(
										    description=_DESCRIPTION			,			citation=_CITATION			,			inputs_description=_KWARGS_DESCRIPTION			,			features=datasets.Features(
										        {
										            '''predictions''': datasets.Value('''int64'''	)
										            if self.config_name != '''cvit-mkb-clsr'''
										            else datasets.Sequence(datasets.Value('''float32'''	)	),
										            '''references''': datasets.Value('''int64'''	)
										            if self.config_name != '''cvit-mkb-clsr'''
										            else datasets.Sequence(datasets.Value('''float32'''	)	),
										        }	)			,			codebase_urls=[]			,			reference_urls=[]			,			format='''numpy''' if self.config_name != '''cvit-mkb-clsr''' else None			,			)



				def 		__magic_name__(       self			:List[str]			,			lowerCAmelCase__			:Optional[Any]			,			lowerCAmelCase__			:Tuple	)		->			str:
										if self.config_name == "cvit-mkb-clsr":
																return {"precision@10": precision_at_aa(lowerCAmelCase__			,			lowerCAmelCase__	)}
										elif self.config_name in ["wiki-ner"]:
																return acc_and_fa(lowerCAmelCase__			,			lowerCAmelCase__	)
										elif self.config_name in [
										    "wnli",
										    "copa",
										    "sna",
										    "csqa",
										    "wstp",
										    "inltkh",
										    "bbca",
										    "iitp-mr",
										    "iitp-pr",
										    "actsa-sc",
										    "md",
										]:
																return {"accuracy": simple_accuracy(lowerCAmelCase__			,			lowerCAmelCase__	)}
										else:
																raise KeyError(
																    '''You should supply a configuration name selected in '''
																    '''["wnli", "copa", "sna", "csqa", "wstp", "inltkh", "bbca", '''
																    '''"cvit-mkb-clsr", "iitp-mr", "iitp-pr", "actsa-sc", "md", '''
																    '''"wiki-ner"]'''	)
