






from __future__ import annotations

from collections import deque
from enum import Enum
from math import atana, degrees
from sys import maxsize




class        snake_case_					(						A__			):

						"""simple docstring"""



						snake_case__   					=			1
						snake_case__   					=			2
						snake_case__   					=			3



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




											'''simple docstring'''



											return f'{self.__class__.__name__}.{self.name}'







def 						a_      (__A							,					__A							,					__A			)							->	float:



					"""simple docstring"""
					__a				:	Any			=				point
					return degrees(atana(y - miny							,					x - minx			)			)







def 						a_      (__A							,					__A							,					__A			)							->	Direction:



					"""simple docstring"""
					__a				:	Optional[Any]			=				starting
					__a				:	Tuple			=				via
					__a				:	Optional[Any]			=				target
					__a				:	List[str]			=				degrees(atana(ya - ya							,					xa - xa			)			)
					via_angle %= 360
					__a				:	int			=				degrees(atana(ya - ya							,					xa - xa			)			)
					target_angle %= 360
					# t-
					#  \ \
					#   \ v
					#    \|
					#     s
					# via_angle is always lower than target_angle, if direction is left.
					# If they are same, it means they are on a same line of convex hull.
					if target_angle > via_angle:
										return Direction.left
					elif target_angle == via_angle:
										return Direction.straight
					else:
										return Direction.right







def 						a_      (__A			)							->	list[tuple[int, int]]:



					"""simple docstring"""

					if len(__lowerCAmelCase			) <= 2:
										# There is no convex hull
										raise ValueError("graham_scan: argument must contain more than 3 points."			)
					if len(__lowerCAmelCase			) == 3:
										return points
					# find the lowest and the most left point
					__a				:	Any			=				0
					__a				:	Optional[int]			=				maxsize, maxsize
					for i, point in enumerate(__lowerCAmelCase			):
										__a				:	List[str]			=				point[0]
										__a				:	Any			=				point[1]
										if y < miny:
															__a				:	str			=				y
															__a				:	int			=				x
															__a				:	List[str]			=				i
										if y == miny and x < minx:
															__a				:	Any			=				x
															__a				:	Union[str, Any]			=				i

    # remove the lowest and the most left point from points for preparing for sort
					points.pop(__lowerCAmelCase			)

					__a				:	List[Any]			=				sorted(__lowerCAmelCase							,					key=lambda __A			: angle_comparer(__lowerCAmelCase							,					__lowerCAmelCase							,					__lowerCAmelCase			)			)
					# This insert actually costs complexity,
					# and you should instead add (minx, miny) into stack later.
					# I'm using insert just for easy understanding.
					sorted_points.insert(0							,					(minx, miny)			)

					__a				:	deque[tuple[int, int]]			=				deque()
					stack.append(sorted_points[0]			)
					stack.append(sorted_points[1]			)
					stack.append(sorted_points[2]			)
					# In any ways, the first 3 points line are towards left.
					# Because we sort them the angle from minx, miny.
					__a				:	Dict			=				Direction.left

					for i in range(3							,					len(__lowerCAmelCase			)			):
										while True:
															__a				:	Dict			=				stack[-2]
															__a				:	List[str]			=				stack[-1]
															__a				:	List[str]			=				sorted_points[i]
															__a				:	Optional[int]			=				check_direction(__lowerCAmelCase							,					__lowerCAmelCase							,					__lowerCAmelCase			)

															if next_direction == Direction.left:
																				__a				:	Dict			=				Direction.left
																				break
															if next_direction == Direction.straight:
																				if current_direction == Direction.left:
																									# We keep current_direction as left.
																									# Because if the straight line keeps as straight,
																									# we want to know if this straight line is towards left.
																									break
																				elif current_direction == Direction.right:
																									# If the straight line is towards right,
																									# every previous points on those straigh line is not convex hull.
																									stack.pop()
															if next_direction == Direction.right:
																				stack.pop()
										stack.append(sorted_points[i]			)
					return list(__lowerCAmelCase			)













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)))





