






import unittest
from dataclasses import dataclass
from typing import Optional

from transformers.utils import ModelOutput




@dataclass
class        snake_case_					(						__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			42
						snake_case__   					=			None
						snake_case__   					=			None




class        snake_case_					(						unittest.TestCase			):

						"""simple docstring"""



						def 					UpperCAmelCase__				(self:				Optional[Any]      )						->    Tuple:




											'''simple docstring'''



											__a				:	List[str]			=				ModelOutputTest(a=30      )
											self.assertEqual(x.a   ,				30      )
											self.assertIsNone(x.b      )
											self.assertIsNone(x.c      )
											with self.assertRaises(__UpperCAmelCase      ):
																__a				:	Tuple			=				x.d



						def 					UpperCAmelCase__				(self:				Dict      )						->    Union[str, Any]:




											'''simple docstring'''



											__a				:	Union[str, Any]			=				ModelOutputTest(a=30   ,				b=10      )
											self.assertEqual(x[0]   ,				30      )
											self.assertEqual(x[1]   ,				10      )
											self.assertEqual(x[:2]   ,				(30, 10)      )
											self.assertEqual(x[:]   ,				(30, 10)      )

											__a				:	int			=				ModelOutputTest(a=30   ,				c=10      )
											self.assertEqual(x[0]   ,				30      )
											self.assertEqual(x[1]   ,				10      )
											self.assertEqual(x[:2]   ,				(30, 10)      )
											self.assertEqual(x[:]   ,				(30, 10)      )



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




											'''simple docstring'''



											__a				:	Optional[Any]			=				ModelOutputTest(a=30   ,				b=10      )
											self.assertEqual(x["a"]   ,				30      )
											self.assertEqual(x["b"]   ,				10      )
											with self.assertRaises(__UpperCAmelCase      ):
																__a				:	List[str]			=				x["c"]

											__a				:	Union[str, Any]			=				ModelOutputTest(a=30   ,				c=10      )
											self.assertEqual(x["a"]   ,				30      )
											self.assertEqual(x["c"]   ,				10      )
											with self.assertRaises(__UpperCAmelCase      ):
																__a				:	int			=				x["b"]



						def 					UpperCAmelCase__				(self:				Union[str, Any]      )						->    Optional[int]:




											'''simple docstring'''



											__a				:	Union[str, Any]			=				ModelOutputTest(a=30      )
											self.assertEqual(list(x.keys()      )   ,				["a"]      )
											self.assertEqual(list(x.values()      )   ,				[30]      )
											self.assertEqual(list(x.items()      )   ,				[("a", 30)]      )
											self.assertEqual(list(__UpperCAmelCase      )   ,				["a"]      )

											__a				:	List[str]			=				ModelOutputTest(a=30   ,				b=10      )
											self.assertEqual(list(x.keys()      )   ,				["a", "b"]      )
											self.assertEqual(list(x.values()      )   ,				[30, 10]      )
											self.assertEqual(list(x.items()      )   ,				[("a", 30), ("b", 10)]      )
											self.assertEqual(list(__UpperCAmelCase      )   ,				["a", "b"]      )

											__a				:	str			=				ModelOutputTest(a=30   ,				c=10      )
											self.assertEqual(list(x.keys()      )   ,				["a", "c"]      )
											self.assertEqual(list(x.values()      )   ,				[30, 10]      )
											self.assertEqual(list(x.items()      )   ,				[("a", 30), ("c", 10)]      )
											self.assertEqual(list(__UpperCAmelCase      )   ,				["a", "c"]      )

											with self.assertRaises(__UpperCAmelCase      ):
																__a				:	Dict			=				x.update({"d": 20}      )
											with self.assertRaises(__UpperCAmelCase      ):
																del x["a"]
											with self.assertRaises(__UpperCAmelCase      ):
																__a				:	Any			=				x.pop("a"      )
											with self.assertRaises(__UpperCAmelCase      ):
																__a				:	Any			=				x.setdefault("d"   ,				32      )



						def 					UpperCAmelCase__				(self:				Optional[Any]      )						->    Optional[Any]:




											'''simple docstring'''



											__a				:	Optional[Any]			=				ModelOutputTest(a=30      )
											__a				:	int			=				10
											self.assertEqual(x.a   ,				10      )
											self.assertEqual(x["a"]   ,				10      )



						def 					UpperCAmelCase__				(self:				Optional[Any]      )						->    Any:




											'''simple docstring'''



											__a				:	Optional[int]			=				ModelOutputTest(a=30      )
											__a				:	int			=				10
											self.assertEqual(x.a   ,				10      )
											self.assertEqual(x["a"]   ,				10      )



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




											'''simple docstring'''



											__a				:	Dict			=				ModelOutputTest({"a": 30, "b": 10}      )
											self.assertEqual(list(x.keys()      )   ,				["a", "b"]      )
											self.assertEqual(x.a   ,				30      )
											self.assertEqual(x.b   ,				10      )



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




											'''simple docstring'''



											__a				:	List[Any]			=				ModelOutputTest([("a", 30), ("b", 10)]      )
											self.assertEqual(list(x.keys()      )   ,				["a", "b"]      )
											self.assertEqual(x.a   ,				30      )
											self.assertEqual(x.b   ,				10      )

											with self.assertRaises(__UpperCAmelCase      ):
																__a				:	List[Any]			=				ModelOutputTest([("a", 30), (10, 10)]      )

											__a				:	Optional[Any]			=				ModelOutputTest(a=(30, 30)      )
											self.assertEqual(list(x.keys()      )   ,				["a"]      )
											self.assertEqual(x.a   ,				(30, 30)      )













import argparse
import json
import re
import string
import sys
from collections import Counter







def 						a_      (__A			)							->	Optional[Any]:



					"""simple docstring"""

					def remove_articles(__A			):
										return re.sub(r"\b(a|an|the)\b"							,					" "							,					__A			)

					def white_space_fix(__A			):
										return " ".join(text.split()			)

					def remove_punc(__A			):
										__a				:	Union[str, Any]			=				set(string.punctuation			)
										return "".join(ch for ch in text if ch not in exclude			)

					def lower(__A			):
										return text.lower()

					return white_space_fix(remove_articles(remove_punc(lower(__A			)			)			)			)







def 						a_      (__A							,					__A			)							->	Union[str, Any]:



					"""simple docstring"""
					__a				:	str			=				normalize_answer(__A			).split()
					__a				:	Dict			=				normalize_answer(__A			).split()
					__a				:	List[Any]			=				Counter(__A			) & Counter(__A			)
					__a				:	List[Any]			=				sum(common.values()			)
					if num_same == 0:
										return 0
					__a				:	Optional[Any]			=				1.0 * num_same / len(__A			)
					__a				:	int			=				1.0 * num_same / len(__A			)
					__a				:	List[str]			=				(2 * precision * recall) / (precision + recall)
					return fa







def 						a_      (__A							,					__A			)							->	Dict:



					"""simple docstring"""
					return normalize_answer(__A			) == normalize_answer(__A			)







def 						a_      (__A							,					__A							,					__A			)							->	Optional[Any]:



					"""simple docstring"""
					__a				:	str			=				[]
					for ground_truth in ground_truths:
										__a				:	Tuple			=				metric_fn(__A							,					__A			)
										scores_for_ground_truths.append(__A			)
					return max(__A			)







def 						a_      (__A							,					__A			)							->	Union[str, Any]:



					"""simple docstring"""
					__a				:	str			=				0
					for article in dataset:
										for paragraph in article["paragraphs"]:
															for qa in paragraph["qas"]:
																				total += 1
																				if qa["id"] not in predictions:
																									__a				:	str			=				"Unanswered question " + qa["id"] + " will receive score 0."
																									print(__A							,					file=sys.stderr			)
																									continue
																				__a				:	Any			=				[x["text"] for x in qa["answers"]]
																				__a				:	List[Any]			=				predictions[qa["id"]]
																				exact_match += metric_max_over_ground_truths(__A							,					__A							,					__A			)
																				fa += metric_max_over_ground_truths(__A							,					__A							,					__A			)

					__a				:	Any			=				100.0 * exact_match / total
					__a				:	List[Any]			=				100.0 * fa / total

					return {"exact_match": exact_match, "f1": fa}


if __name__ == "__main__":
			UpperCAmelCase__			 =	'''1.1'''
			UpperCAmelCase__			 =	argparse.ArgumentParser(description='''Evaluation for SQuAD ''' + expected_version)
			parser.add_argument('''dataset_file''', help='''Dataset file''')
			parser.add_argument('''prediction_file''', help='''Prediction File''')
			UpperCAmelCase__			 =	parser.parse_args()
			with open(args.dataset_file) as dataset_file:
						UpperCAmelCase__			 =	json.load(dataset_file)
						if dataset_json["version"] != expected_version:
									print(
									    '''Evaluation expects v-''' + expected_version + ''', but got dataset with v-''' + dataset_json['''version'''],
									    file=sys.stderr,
									)
						UpperCAmelCase__			 =	dataset_json['''data''']
			with open(args.prediction_file) as prediction_file:
						UpperCAmelCase__			 =	json.load(prediction_file)
			print(json.dumps(evaluate(dataset, predictions)))





