



import unittest

from transformers import AutoConfig, AutoTokenizer, BertConfig, TensorType, is_flax_available
from transformers.testing_utils import DUMMY_UNKNOWN_IDENTIFIER, require_flax, slow


if is_flax_available():
						import jax

						from transformers.models.auto.modeling_flax_auto import FlaxAutoModel
						from transformers.models.bert.modeling_flax_bert import FlaxBertModel
						from transformers.models.roberta.modeling_flax_roberta import FlaxRobertaModel






@require_flax
class      UpperCamelCase    (						unittest.TestCase     ):



	@slow
	def 			__A							(       self		):
							for model_name in ["bert-base-cased", "bert-large-uncased"]:
													with self.subTest(UpperCAmelCase__		):
																			A__							=       AutoConfig.from_pretrained(UpperCAmelCase__		)
																			self.assertIsNotNone(UpperCAmelCase__		)
																			self.assertIsInstance(UpperCAmelCase__			,	UpperCAmelCase__		)

																			A__							=       FlaxAutoModel.from_pretrained(UpperCAmelCase__		)
																			self.assertIsNotNone(UpperCAmelCase__		)
																			self.assertIsInstance(UpperCAmelCase__			,	UpperCAmelCase__		)



	@slow
	def 			__A							(       self		):
							for model_name in ["roberta-base", "roberta-large"]:
													with self.subTest(UpperCAmelCase__		):
																			A__							=       AutoConfig.from_pretrained(UpperCAmelCase__		)
																			self.assertIsNotNone(UpperCAmelCase__		)
																			self.assertIsInstance(UpperCAmelCase__			,	UpperCAmelCase__		)

																			A__							=       FlaxAutoModel.from_pretrained(UpperCAmelCase__		)
																			self.assertIsNotNone(UpperCAmelCase__		)
																			self.assertIsInstance(UpperCAmelCase__			,	UpperCAmelCase__		)



	@slow
	def 			__A							(       self		):
							for model_name in ["bert-base-cased", "bert-large-uncased"]:
													A__							=       AutoTokenizer.from_pretrained(UpperCAmelCase__		)
													A__							=       FlaxBertModel.from_pretrained(UpperCAmelCase__		)
													A__							=       tokenizer("Do you support jax jitted function?"			,	return_tensors=TensorType.JAX		)

													@jax.jit
													def eval(**UpperCAmelCase__		):
																			return model(**UpperCAmelCase__		)

													eval(**UpperCAmelCase__		).block_until_ready()



	@slow
	def 			__A							(       self		):
							for model_name in ["roberta-base", "roberta-large"]:
													A__							=       AutoTokenizer.from_pretrained(UpperCAmelCase__		)
													A__							=       FlaxRobertaModel.from_pretrained(UpperCAmelCase__		)
													A__							=       tokenizer("Do you support jax jitted function?"			,	return_tensors=TensorType.JAX		)

													@jax.jit
													def eval(**UpperCAmelCase__		):
																			return model(**UpperCAmelCase__		)

													eval(**UpperCAmelCase__		).block_until_ready()



	def 			__A							(       self		):
							with self.assertRaisesRegex(
							    UpperCAmelCase__			,	"bert-base is not a local folder and is not a valid model identifier"		):
													A__							=       FlaxAutoModel.from_pretrained("bert-base"		)



	def 			__A							(       self		):
							with self.assertRaisesRegex(
							    UpperCAmelCase__			,	R"aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)"		):
													A__							=       FlaxAutoModel.from_pretrained(UpperCAmelCase__			,	revision="aaaaaa"		)



	def 			__A							(       self		):
							with self.assertRaisesRegex(
							    UpperCAmelCase__			,	"hf-internal-testing/config-no-model does not appear to have a file named flax_model.msgpack"			,	):
													A__							=       FlaxAutoModel.from_pretrained("hf-internal-testing/config-no-model"		)



	def 			__A							(       self		):
							with self.assertRaisesRegex(UpperCAmelCase__			,	"Use `from_pt=True` to load this model"		):
													A__							=       FlaxAutoModel.from_pretrained("hf-internal-testing/tiny-bert-pt-only"		)










import datasets

from .evaluate import evaluate


UpperCAmelCase_							:      List[Any]      =  "\\n@inproceedings{Rajpurkar2016SQuAD10,\n  title={SQuAD: 100, 000+ Questions for Machine Comprehension of Text},\n  author={Pranav Rajpurkar and Jian Zhang and Konstantin Lopyrev and Percy Liang},\n  booktitle={EMNLP},\n  year={2016}\n}\n"

UpperCAmelCase_							:      Any      =  "\nThis metric wrap the official scoring script for version 1 of the Stanford Question Answering Dataset (SQuAD).\n\nStanford Question Answering Dataset (SQuAD) is a reading comprehension dataset, consisting of questions posed by\ncrowdworkers on a set of Wikipedia articles, where the answer to every question is a segment of text, or span,\nfrom the corresponding reading passage, or the question might be unanswerable.\n"

UpperCAmelCase_							:      Tuple      =  "\nComputes SQuAD scores (F1 and EM).\nArgs:\n    predictions: List of question-answers dictionaries with the following key-values:\n        - 'id': id of the question-answer pair as given in the references (see below)\n        - 'prediction_text': the text of the answer\n    references: List of question-answers dictionaries with the following key-values:\n        - 'id': id of the question-answer pair (see above),\n        - 'answers': a Dict in the SQuAD dataset format\n            {\n                'text': list of possible texts for the answer, as a list of strings\n                'answer_start': list of start positions for the answer, as a list of ints\n            }\n            Note that answer_start values are not taken into account to compute the metric.\nReturns:\n    'exact_match': Exact match (the normalized answer exactly match the gold answer)\n    'f1': The F-score of predicted tokens versus the gold answer\nExamples:\n\n    >>> predictions = [{'prediction_text': '1976', 'id': '56e10a3be3433e1400422b22'}]\n    >>> references = [{'answers': {'answer_start': [97], 'text': ['1976']}, 'id': '56e10a3be3433e1400422b22'}]\n    >>> squad_metric = datasets.load_metric(\"squad\")\n    >>> results = squad_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {'exact_match': 100.0, 'f1': 100.0}\n"






@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION       ,    _KWARGS_DESCRIPTION     )
class      UpperCamelCase    (						datasets.Metric     ):



	def 			__A							(       self		):
							return datasets.MetricInfo(
							    description=_DESCRIPTION			,	citation=_CITATION			,	inputs_description=_KWARGS_DESCRIPTION			,	features=datasets.Features(
							        {
							            "predictions": {"id": datasets.Value("string"		), "prediction_text": datasets.Value("string"		)},
							            "references": {
							                "id": datasets.Value("string"		),
							                "answers": datasets.features.Sequence(
							                    {
							                        "text": datasets.Value("string"		),
							                        "answer_start": datasets.Value("int32"		),
							                    }		),
							            },
							        }		)			,	codebase_urls=["https://rajpurkar.github.io/SQuAD-explorer/"]			,	reference_urls=["https://rajpurkar.github.io/SQuAD-explorer/"]			,	)



	def 			__A							(       self			,	UpperCAmelCase__			,	UpperCAmelCase__		):
							A__							=       {prediction["id"]: prediction["prediction_text"] for prediction in predictions}
							A__							=       [
							    {
							        "paragraphs": [
							            {
							                "qas": [
							                    {
							                        "answers": [{"text": answer_text} for answer_text in ref["answers"]["text"]],
							                        "id": ref["id"],
							                    }
							                    for ref in references
							                ]
							            }
							        ]
							    }
							]
							A__							=       evaluate(dataset=UpperCAmelCase__			,	predictions=UpperCAmelCase__		)
							return score





