



"""simple docstring"""
from sklearn.metrics import fa_score, matthews_corrcoef

import datasets

from .record_evaluation import evaluate as evaluate_record


A:     Dict										=	"\\n@article{wang2019superglue,\n  title={SuperGLUE: A Stickier Benchmark for General-Purpose Language Understanding Systems},\n  author={Wang, Alex and Pruksachatkun, Yada and Nangia, Nikita and Singh, Amanpreet and Michael, Julian and Hill, Felix and Levy, Omer and Bowman, Samuel R},\n  journal={arXiv preprint arXiv:1905.00537},\n  year={2019}\n}\n"

A:     int										=	"\\nSuperGLUE (https://super.gluebenchmark.com/) is a new benchmark styled after\nGLUE with a new set of more difficult language understanding tasks, improved\nresources, and a new public leaderboard.\n"

A:     str										=	"\nCompute SuperGLUE evaluation metric associated to each SuperGLUE dataset.\nArgs:\n    predictions: list of predictions to score. Depending on the SuperGlUE subset:\n        - for 'record': list of question-answer dictionaries with the following keys:\n            - 'idx': index of the question as specified by the dataset\n            - 'prediction_text': the predicted answer text\n        - for 'multirc': list of question-answer dictionaries with the following keys:\n            - 'idx': index of the question-answer pair as specified by the dataset\n            - 'prediction': the predicted answer label\n        - otherwise: list of predicted labels\n    references: list of reference labels. Depending on the SuperGLUE subset:\n        - for 'record': list of question-answers dictionaries with the following keys:\n            - 'idx': index of the question as specified by the dataset\n            - 'answers': list of possible answers\n        - otherwise: list of reference labels\nReturns: depending on the SuperGLUE subset:\n    - for 'record':\n        - 'exact_match': Exact match between answer and gold answer\n        - 'f1': F1 score\n    - for 'multirc':\n        - 'exact_match': Exact match between answer and gold answer\n        - 'f1_m': Per-question macro-F1 score\n        - 'f1_a': Average F1 score over all answers\n    - for 'axb':\n        'matthews_correlation': Matthew Correlation\n    - for 'cb':\n        - 'accuracy': Accuracy\n        - 'f1': F1 score\n    - for all others:\n        - 'accuracy': Accuracy\nExamples:\n\n    >>> super_glue_metric = datasets.load_metric('super_glue', 'copa')  # any of [\"copa\", \"rte\", \"wic\", \"wsc\", \"wsc.fixed\", \"boolq\", \"axg\"]\n    >>> predictions = [0, 1]\n    >>> references = [0, 1]\n    >>> results = super_glue_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {'accuracy': 1.0}\n\n    >>> super_glue_metric = datasets.load_metric('super_glue', 'cb')\n    >>> predictions = [0, 1]\n    >>> references = [0, 1]\n    >>> results = super_glue_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {'accuracy': 1.0, 'f1': 1.0}\n\n    >>> super_glue_metric = datasets.load_metric('super_glue', 'record')\n    >>> predictions = [{'idx': {'passage': 0, 'query': 0}, 'prediction_text': 'answer'}]\n    >>> references = [{'idx': {'passage': 0, 'query': 0}, 'answers': ['answer', 'another_answer']}]\n    >>> results = super_glue_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {'exact_match': 1.0, 'f1': 1.0}\n\n    >>> super_glue_metric = datasets.load_metric('super_glue', 'multirc')\n    >>> predictions = [{'idx': {'answer': 0, 'paragraph': 0, 'question': 0}, 'prediction': 0}, {'idx': {'answer': 1, 'paragraph': 2, 'question': 3}, 'prediction': 1}]\n    >>> references = [0, 1]\n    >>> results = super_glue_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {'exact_match': 1.0, 'f1_m': 1.0, 'f1_a': 1.0}\n\n    >>> super_glue_metric = datasets.load_metric('super_glue', 'axb')\n    >>> references = [0, 1]\n    >>> predictions = [0, 1]\n    >>> results = super_glue_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {'matthews_correlation': 1.0}\n"

def    _snake_case		(		UpperCamelCase		:	List[Any]    ,	UpperCamelCase		:	List[str]		):
 return float((preds == labels).mean()		)

def    _snake_case		(		UpperCamelCase		:	Dict    ,	UpperCamelCase		:	str    ,	UpperCamelCase		:	str="binary"		):
 UpperCAmelCase			:      Union[str, Any]			=			simple_accuracy(UpperCamelCase    ,	UpperCamelCase		)
 UpperCAmelCase			:      Dict			=			float(fa_score(y_true=UpperCamelCase    ,	y_pred=UpperCamelCase    ,	average=UpperCamelCase		)		)
 return {
     "accuracy": acc,
     "f1": fa,
 }

def    _snake_case		(		UpperCamelCase		:	int    ,	UpperCamelCase		:	List[Any]		):
 UpperCAmelCase			:      int			=			{}
 for id_pred, label in zip(UpperCamelCase    ,	UpperCamelCase		):
  UpperCAmelCase			:      List[str]			=			F"{id_pred['idx']['paragraph']}-{id_pred['idx']['question']}"
  UpperCAmelCase			:      Optional[int]			=			id_pred["""prediction"""]
  if question_id in question_map:
   question_map[question_id].append((pred, label)		)
  else:
   UpperCAmelCase			:      List[str]			=			[(pred, label)]
 UpperCAmelCase			:      List[Any]			=			[], []
 for question, preds_labels in question_map.items():
  UpperCAmelCase			:      Union[str, Any]			=			zip(*UpperCamelCase		)
  UpperCAmelCase			:      Tuple			=			fa_score(y_true=UpperCamelCase    ,	y_pred=UpperCamelCase    ,	average="""macro"""		)
  fas.append(UpperCamelCase		)
  UpperCAmelCase			:      str			=			int(sum(pred == label for pred, label in preds_labels		) == len(UpperCamelCase		)		)
  ems.append(UpperCamelCase		)
 UpperCAmelCase			:      Any			=			float(sum(UpperCamelCase		) / len(UpperCamelCase		)		)
 UpperCAmelCase			:      Optional[Any]			=			sum(UpperCamelCase		) / len(UpperCamelCase		)
 UpperCAmelCase			:      str			=			float(fa_score(y_true=UpperCamelCase    ,	y_pred=[id_pred["""prediction"""] for id_pred in ids_preds]		)		)
 return {"exact_match": em, "f1_m": fa_m, "f1_a": fa_a}



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

   def 			SCREAMING_SNAKE_CASE  (     self		)						->   List[Any]:





    '''simple docstring'''




    if self.config_name not in [
        "boolq",
        "cb",
        "copa",
        "multirc",
        "record",
        "rte",
        "wic",
        "wsc",
        "wsc.fixed",
        "axb",
        "axg",
    ]:
     raise KeyError(
         """You should supply a configuration name selected in """
         """[\"boolq\", \"cb\", \"copa\", \"multirc\", \"record\", \"rte\", \"wic\", \"wsc\", \"wsc.fixed\", \"axb\", \"axg\",]"""		)
    return datasets.MetricInfo(
        description=_DESCRIPTION   ,  citation=_CITATION   ,  inputs_description=_KWARGS_DESCRIPTION   ,  features=datasets.Features(self._get_feature_types()		)   ,  codebase_urls=[]   ,  reference_urls=[]   ,  format="""numpy""" if not self.config_name == """record""" and not self.config_name == """multirc""" else None   ,  )

   def 			SCREAMING_SNAKE_CASE  (     self		)						->   List[str]:





    '''simple docstring'''




    if self.config_name == "record":
     return {
         "predictions": {
             "idx": {
                 "passage": datasets.Value("""int64"""		),
                 "query": datasets.Value("""int64"""		),
             },
             "prediction_text": datasets.Value("""string"""		),
         },
         "references": {
             "idx": {
                 "passage": datasets.Value("""int64"""		),
                 "query": datasets.Value("""int64"""		),
             },
             "answers": datasets.Sequence(datasets.Value("""string"""		)		),
         },
     }
    elif self.config_name == "multirc":
     return {
         "predictions": {
             "idx": {
                 "answer": datasets.Value("""int64"""		),
                 "paragraph": datasets.Value("""int64"""		),
                 "question": datasets.Value("""int64"""		),
             },
             "prediction": datasets.Value("""int64"""		),
         },
         "references": datasets.Value("""int64"""		),
     }
    else:
     return {
         "predictions": datasets.Value("""int64"""		),
         "references": datasets.Value("""int64"""		),
     }




   def 			SCREAMING_SNAKE_CASE  (     self   ,  _SCREAMING_SNAKE_CASE   ,  _SCREAMING_SNAKE_CASE		)						->   List[Any]:





    '''simple docstring'''




    if self.config_name == "axb":
     return {"matthews_correlation": matthews_corrcoef(_SCREAMING_SNAKE_CASE   ,  _SCREAMING_SNAKE_CASE		)}
    elif self.config_name == "cb":
     return acc_and_fa(_SCREAMING_SNAKE_CASE   ,  _SCREAMING_SNAKE_CASE   ,  fa_avg="""macro"""		)
    elif self.config_name == "record":
     UpperCAmelCase			:      str			=			[
         {
             """qas""": [
                 {"""id""": ref["""idx"""]["""query"""], """answers""": [{"""text""": ans} for ans in ref["""answers"""]]}
                 for ref in references
             ]
         }
     ]
     UpperCAmelCase			:      Tuple			=			{pred["""idx"""]["""query"""]: pred["""prediction_text"""] for pred in predictions}
     return evaluate_record(_SCREAMING_SNAKE_CASE   ,  _SCREAMING_SNAKE_CASE		)[0]
    elif self.config_name == "multirc":
     return evaluate_multirc(_SCREAMING_SNAKE_CASE   ,  _SCREAMING_SNAKE_CASE		)
    elif self.config_name in ["copa", "rte", "wic", "wsc", "wsc.fixed", "boolq", "axg"]:
     return {"accuracy": simple_accuracy(_SCREAMING_SNAKE_CASE   ,  _SCREAMING_SNAKE_CASE		)}
    else:
     raise KeyError(
         """You should supply a configuration name selected in """
         """[\"boolq\", \"cb\", \"copa\", \"multirc\", \"record\", \"rte\", \"wic\", \"wsc\", \"wsc.fixed\", \"axb\", \"axg\",]"""		)











"""simple docstring"""
import math
from datetime import datetime, timedelta

def    _snake_case		(		UpperCamelCase		:	int		):
 UpperCAmelCase			:      Any			=			year % 19
 UpperCAmelCase			:      Any			=			year % 4
 UpperCAmelCase			:      str			=			year % 7
 UpperCAmelCase			:      Union[str, Any]			=			math.floor(year / 100		)
 UpperCAmelCase			:      Optional[Any]			=			math.floor((13 + 8 * leap_day_inhibits) / 25		)
 UpperCAmelCase			:      int			=			leap_day_inhibits / 4
 UpperCAmelCase			:      int			=			(
     15 - lunar_orbit_correction + leap_day_inhibits - leap_day_reinstall_number
 ) % 30
 UpperCAmelCase			:      Tuple			=			(4 + leap_day_inhibits - leap_day_reinstall_number) % 7

 # days to be added to March 21
 UpperCAmelCase			:      int			=			(19 * metonic_cycle + secular_moon_shift) % 30

 # PHM -> Paschal Full Moon
 UpperCAmelCase			:      Tuple			=			(
     2 * julian_leap_year
     + 4 * non_leap_year
     + 6 * days_to_add
     + century_starting_point
 ) % 7

 if days_to_add == 29 and days_from_phm_to_sunday == 6:
  return datetime(UpperCamelCase    ,	4    ,	19		)
 elif days_to_add == 28 and days_from_phm_to_sunday == 6:
  return datetime(UpperCamelCase    ,	4    ,	18		)
 else:
  return datetime(UpperCamelCase    ,	3    ,	22		) + timedelta(
      days=int(days_to_add + days_from_phm_to_sunday		)		)


if __name__ == "__main__":
      for year in (1_9_9_4, 2_0_0_0, 2_0_1_0, 2_0_2_1, 2_0_2_3):
            A:     Any										=	"will be" if year > datetime.now().year else "was"
            print(f"""Easter in {year} {tense} {gauss_easter(year)}""")
