






"""simple docstring"""


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





def 							a__     (					_UpperCAmelCase		)      ->					Any:

 '''simple docstring'''






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

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

 def remove_punc(_UpperCAmelCase		):
  snake_case__      							=			set(string.punctuation		)
  return "".join(ch for ch in text if ch not in exclude		)

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

 return white_space_fix(remove_articles(remove_punc(lower(_UpperCAmelCase		)		)		)		)





def 							a__     (					_UpperCAmelCase		,       _UpperCAmelCase		)      ->					Optional[Any]:

 '''simple docstring'''






 snake_case__      							=			normalize_answer(_UpperCAmelCase		).split()
 snake_case__      							=			normalize_answer(_UpperCAmelCase		).split()
 snake_case__      							=			Counter(_UpperCAmelCase		) & Counter(_UpperCAmelCase		)
 snake_case__      							=			sum(common.values()		)
 if num_same == 0:
  return 0
 snake_case__      							=			1.0 * num_same / len(_UpperCAmelCase		)
 snake_case__      							=			1.0 * num_same / len(_UpperCAmelCase		)
 snake_case__      							=			(2 * precision * recall) / (precision + recall)
 return fa





def 							a__     (					_UpperCAmelCase		,       _UpperCAmelCase		)      ->					str:

 '''simple docstring'''






 return normalize_answer(_UpperCAmelCase		) == normalize_answer(_UpperCAmelCase		)





def 							a__     (					_UpperCAmelCase		,       _UpperCAmelCase		,       _UpperCAmelCase		)      ->					Dict:

 '''simple docstring'''






 snake_case__      							=			[]
 for ground_truth in ground_truths:
  snake_case__      							=			metric_fn(_UpperCAmelCase		,       _UpperCAmelCase		)
  scores_for_ground_truths.append(_UpperCAmelCase		)
 return max(_UpperCAmelCase		)





def 							a__     (					_UpperCAmelCase		,       _UpperCAmelCase		)      ->					List[Any]:

 '''simple docstring'''






 snake_case__      							=			0
 snake_case__      							=			[]
 for passage in dataset:
  for qa in passage["qas"]:
   total += 1
   if qa["id"] not in predictions:
    snake_case__      							=			f"Unanswered question {qa['id']} will receive score 0."
    print(_UpperCAmelCase		,       file=sys.stderr		)
    continue

   snake_case__      							=			[x["text"] for x in qa["answers"]]
   snake_case__      							=			predictions[qa["id"]]

   snake_case__      							=			metric_max_over_ground_truths(_UpperCAmelCase		,       _UpperCAmelCase		,       _UpperCAmelCase		)
   if int(_exact_match		) == 1:
    correct_ids.append(qa["id"]		)
   exact_match += _exact_match

   fa += metric_max_over_ground_truths(_UpperCAmelCase		,       _UpperCAmelCase		,       _UpperCAmelCase		)

 snake_case__      							=			exact_match / total
 snake_case__      							=			fa / total

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


if __name__ == "__main__":
   a__   :       str   						=			"""1.0"""
   a__   :       Any   						=			argparse.ArgumentParser("""Official evaluation script for ReCoRD v1.0.""")
   parser.add_argument("""data_file""", help="""The dataset file in JSON format.""")
   parser.add_argument("""pred_file""", help="""The model prediction file in JSON format.""")
   parser.add_argument("""--output_correct_ids""", action="""store_true""", help="""Output the correctly answered query IDs.""")
   a__   :       Dict   						=			parser.parse_args()

   with open(args.data_file) as data_file:
      a__   :       Optional[Any]   						=			json.load(data_file)
      if dataset_json["version"] != expected_version:
         print(
             f'''Evaluation expects v-{expected_version}, but got dataset with v-{dataset_json['version']}''',
             file=sys.stderr,
         )
      a__   :       List[Any]   						=			dataset_json["""data"""]

   with open(args.pred_file) as pred_file:
      a__   :       List[str]   						=			json.load(pred_file)

   a__						,	a__   :       int   						=			evaluate(dataset, predictions)

   if args.output_correct_ids:
      print(f'''Output {len(correct_ids)} correctly answered question IDs.''')
      with open("""correct_ids.json""", """w""") as f:
         json.dump(correct_ids, f)








"""simple docstring"""


from __future__ import annotations

from math import pi, pow





def 							a__     (					_UpperCAmelCase		)      ->					float:

 '''simple docstring'''






 if side_length < 0:
  raise ValueError("vol_cube() only accepts non-negative values"		)
 return pow(_UpperCAmelCase		,       3		)





def 							a__     (					_UpperCAmelCase		,       _UpperCAmelCase		)      ->					float:

 '''simple docstring'''






 if height < 0 or radius < 0:
  raise ValueError("vol_spherical_cap() only accepts non-negative values"		)
 # Volume is 1/3 pi * height squared * (3 * radius - height)
 return 1 / 3 * pi * pow(_UpperCAmelCase		,       2		) * (3 * radius - height)





def 							a__     (					_UpperCAmelCase		,       _UpperCAmelCase		,       _UpperCAmelCase		)      ->					float:

 '''simple docstring'''






 if radius_a < 0 or radius_a < 0 or centers_distance < 0:
  raise ValueError("vol_spheres_intersect() only accepts non-negative values"		)
 if centers_distance == 0:
  return vol_sphere(min(_UpperCAmelCase		,       _UpperCAmelCase		)		)

 snake_case__      							=			(
     (radius_a - radius_a + centers_distance)
     * (radius_a + radius_a - centers_distance)
     / (2 * centers_distance)
 )
 snake_case__      							=			(
     (radius_a - radius_a + centers_distance)
     * (radius_a + radius_a - centers_distance)
     / (2 * centers_distance)
 )

 return vol_spherical_cap(_UpperCAmelCase		,       _UpperCAmelCase		) + vol_spherical_cap(_UpperCAmelCase		,       _UpperCAmelCase		)





def 							a__     (					_UpperCAmelCase		,       _UpperCAmelCase		,       _UpperCAmelCase		)      ->					float:

 '''simple docstring'''






 if radius_a <= 0 or radius_a <= 0 or centers_distance < 0:
  raise ValueError(
      "vol_spheres_union() only accepts non-negative values, non-zero radius"		)

 if centers_distance == 0:
  return vol_sphere(max(_UpperCAmelCase		,       _UpperCAmelCase		)		)

 return (
     vol_sphere(_UpperCAmelCase		)
     + vol_sphere(_UpperCAmelCase		)
     - vol_spheres_intersect(_UpperCAmelCase		,       _UpperCAmelCase		,       _UpperCAmelCase		)
 )





def 							a__     (					_UpperCAmelCase		,       _UpperCAmelCase		,       _UpperCAmelCase		)      ->					float:

 '''simple docstring'''






 if width < 0 or height < 0 or length < 0:
  raise ValueError("vol_cuboid() only accepts non-negative values"		)
 return float(width * height * length		)





def 							a__     (					_UpperCAmelCase		,       _UpperCAmelCase		)      ->					float:

 '''simple docstring'''






 if height < 0 or area_of_base < 0:
  raise ValueError("vol_cone() only accepts non-negative values"		)
 return area_of_base * height / 3.0





def 							a__     (					_UpperCAmelCase		,       _UpperCAmelCase		)      ->					float:

 '''simple docstring'''






 if height < 0 or radius < 0:
  raise ValueError("vol_right_circ_cone() only accepts non-negative values"		)
 return pi * pow(_UpperCAmelCase		,       2		) * height / 3.0





def 							a__     (					_UpperCAmelCase		,       _UpperCAmelCase		)      ->					float:

 '''simple docstring'''






 if height < 0 or area_of_base < 0:
  raise ValueError("vol_prism() only accepts non-negative values"		)
 return float(area_of_base * height		)





def 							a__     (					_UpperCAmelCase		,       _UpperCAmelCase		)      ->					float:

 '''simple docstring'''






 if height < 0 or area_of_base < 0:
  raise ValueError("vol_pyramid() only accepts non-negative values"		)
 return area_of_base * height / 3.0





def 							a__     (					_UpperCAmelCase		)      ->					float:

 '''simple docstring'''






 if radius < 0:
  raise ValueError("vol_sphere() only accepts non-negative values"		)
 # Volume is 4/3 * pi * radius cubed
 return 4 / 3 * pi * pow(_UpperCAmelCase		,       3		)





def 							a__     (					_UpperCAmelCase		)      ->					float:

 '''simple docstring'''






 if radius < 0:
  raise ValueError("vol_hemisphere() only accepts non-negative values"		)
 # Volume is radius cubed * pi * 2/3
 return pow(_UpperCAmelCase		,       3		) * pi * 2 / 3





def 							a__     (					_UpperCAmelCase		,       _UpperCAmelCase		)      ->					float:

 '''simple docstring'''






 if height < 0 or radius < 0:
  raise ValueError("vol_circular_cylinder() only accepts non-negative values"		)
 # Volume is radius squared * height * pi
 return pow(_UpperCAmelCase		,       2		) * height * pi





def 							a__     (					_UpperCAmelCase		,       _UpperCAmelCase		,       _UpperCAmelCase		)      ->					float:

 '''simple docstring'''






 if inner_radius < 0 or outer_radius < 0 or height < 0:
  raise ValueError(
      "vol_hollow_circular_cylinder() only accepts non-negative values"		)
 if outer_radius <= inner_radius:
  raise ValueError("outer_radius must be greater than inner_radius"		)
 return pi * (pow(_UpperCAmelCase		,       2		) - pow(_UpperCAmelCase		,       2		)) * height





def 							a__     (					_UpperCAmelCase		,       _UpperCAmelCase		,       _UpperCAmelCase		)      ->					float:

 '''simple docstring'''






 if radius_a < 0 or radius_a < 0 or height < 0:
  raise ValueError("vol_conical_frustum() only accepts non-negative values"		)
 return (
     1
     / 3
     * pi
     * height
     * (pow(_UpperCAmelCase		,       2		) + pow(_UpperCAmelCase		,       2		) + radius_a * radius_a)
 )





def 							a__     (					_UpperCAmelCase		,       _UpperCAmelCase		)      ->					float:

 '''simple docstring'''






 if torus_radius < 0 or tube_radius < 0:
  raise ValueError("vol_torus() only accepts non-negative values"		)
 return 2 * pow(_UpperCAmelCase		,       2		) * torus_radius * pow(_UpperCAmelCase		,       2		)





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

 '''simple docstring'''






 print("Volumes:"		)
 print(f"Cube: {vol_cube(2		) = }"		)  # = 8
 print(f"Cuboid: {vol_cuboid(2		,       2		,       2		) = }"		)  # = 8
 print(f"Cone: {vol_cone(2		,       2		) = }"		)  # ~= 1.33
 print(f"Right Circular Cone: {vol_right_circ_cone(2		,       2		) = }"		)  # ~= 8.38
 print(f"Prism: {vol_prism(2		,       2		) = }"		)  # = 4
 print(f"Pyramid: {vol_pyramid(2		,       2		) = }"		)  # ~= 1.33
 print(f"Sphere: {vol_sphere(2		) = }"		)  # ~= 33.5
 print(f"Hemisphere: {vol_hemisphere(2		) = }"		)  # ~= 16.75
 print(f"Circular Cylinder: {vol_circular_cylinder(2		,       2		) = }"		)  # ~= 25.1
 print(f"Torus: {vol_torus(2		,       2		) = }"		)  # ~= 157.9
 print(f"Conical Frustum: {vol_conical_frustum(2		,       2		,       4		) = }"		)  # ~= 58.6
 print(f"Spherical cap: {vol_spherical_cap(1		,       2		) = }"		)  # ~= 5.24
 print(f"Spheres intersetion: {vol_spheres_intersect(2		,       2		,       1		) = }"		)  # ~= 21.21
 print(f"Spheres union: {vol_spheres_union(2		,       2		,       1		) = }"		)  # ~= 45.81
 print(
     f"Hollow Circular Cylinder: {vol_hollow_circular_cylinder(1		,       2		,       3		) = }"		)  # ~= 28.3


if __name__ == "__main__":
   main()

