


'''simple docstring'''

import re
import string
from collections import Counter

import sacrebleu
import sacremoses
from packaging import version

import datasets


_UpperCAmelCase				: Dict							    =				"""
@inproceedings{xu-etal-2016-optimizing,
    title = {Optimizing Statistical Machine Translation for Text Simplification},
    authors={Xu, Wei and Napoles, Courtney and Pavlick, Ellie and Chen, Quanze and Callison-Burch, Chris},
    journal = {Transactions of the Association for Computational Linguistics},
    volume = {4},
    year={2016},
    url = {https://www.aclweb.org/anthology/Q16-1029},
    pages = {401--415
},
@inproceedings{post-2018-call,
    title = \"A Call for Clarity in Reporting {BLEU} Scores\",
    author = \"Post, Matt\",
    booktitle = \"Proceedings of the Third Conference on Machine Translation: Research Papers\",
    month = oct,
    year = \"2018\",
    address = \"Belgium, Brussels\",
    publisher = \"Association for Computational Linguistics\",
    url = \"https://www.aclweb.org/anthology/W18-6319\",
    pages = \"186--191\",
}
"""

_UpperCAmelCase				: List[str]							    =				"""\
WIKI_SPLIT is the combination of three metrics SARI, EXACT and SACREBLEU
It can be used to evaluate the quality of machine-generated texts.
"""


_UpperCAmelCase				: int							    =				"""
Calculates sari score (between 0 and 100) given a list of source and predicted
sentences, and a list of lists of reference sentences. It also computes the BLEU score as well as the exact match score.
Args:
    sources: list of source sentences where each sentence should be a string.
    predictions: list of predicted sentences where each sentence should be a string.
    references: list of lists of reference sentences where each sentence should be a string.
Returns:
    sari: sari score
    sacrebleu: sacrebleu score
    exact: exact score

Examples:
    >>> sources=[\"About 95 species are currently accepted .\"]
    >>> predictions=[\"About 95 you now get in .\"]
    >>> references=[[\"About 95 species are currently known .\"]]
    >>> wiki_split = datasets.load_metric(\"wiki_split\")
    >>> results = wiki_split.compute(sources=sources, predictions=predictions, references=references)
    >>> print(results)
    {'sari': 21.805555555555557, 'sacrebleu': 14.535768424205482, 'exact': 0.0}
"""

def 							__magic_name__(						lowerCamelCase):

						def remove_articles(lowerCamelCase):
												__lowerCAmelCase							       =				re.compile(r'''\b(a|an|the)\b''',				re.UNICODE)
												return re.sub(lowerCamelCase,				''' ''',				lowerCamelCase)

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

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

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

						return white_space_fix(remove_articles(remove_punc(lower(lowerCamelCase))))

def 							__magic_name__(						lowerCamelCase,				lowerCamelCase):
						return int(normalize_answer(lowerCamelCase) == normalize_answer(lowerCamelCase))

def 							__magic_name__(						lowerCamelCase,				lowerCamelCase):
						__lowerCAmelCase							       =				[any(compute_exact(lowerCamelCase,				lowerCamelCase) for ref in refs) for pred, refs in zip(lowerCamelCase,				lowerCamelCase)]
						return (sum(lowerCamelCase) / len(lowerCamelCase)) * 1_0_0

def 							__magic_name__(						lowerCamelCase,				lowerCamelCase,				lowerCamelCase,				lowerCamelCase):
						__lowerCAmelCase							       =				[rgram for rgrams in rgramslist for rgram in rgrams]
						__lowerCAmelCase							       =				Counter(lowerCamelCase)

						__lowerCAmelCase							       =				Counter(lowerCamelCase)
						__lowerCAmelCase							       =				Counter()
						for sgram, scount in sgramcounter.items():
												__lowerCAmelCase							       =				scount * numref

						__lowerCAmelCase							       =				Counter(lowerCamelCase)
						__lowerCAmelCase							       =				Counter()
						for cgram, ccount in cgramcounter.items():
												__lowerCAmelCase							       =				ccount * numref

						# KEEP
						__lowerCAmelCase							       =				sgramcounter_rep & cgramcounter_rep
						__lowerCAmelCase							       =				keepgramcounter_rep & rgramcounter
						__lowerCAmelCase							       =				sgramcounter_rep & rgramcounter

						__lowerCAmelCase							       =				0
						__lowerCAmelCase							       =				0
						for keepgram in keepgramcountergood_rep:
												keeptmpscorea += keepgramcountergood_rep[keepgram] / keepgramcounter_rep[keepgram]
												# Fix an alleged bug [2] in the keep score computation.
												# keeptmpscore2 += keepgramcountergood_rep[keepgram] / keepgramcounterall_rep[keepgram]
												keeptmpscorea += keepgramcountergood_rep[keepgram]
						# Define 0/0=1 instead of 0 to give higher scores for predictions that match
						#      a target exactly.
						__lowerCAmelCase							       =				1
						__lowerCAmelCase							       =				1
						if len(lowerCamelCase) > 0:
												__lowerCAmelCase							       =				keeptmpscorea / len(lowerCamelCase)
						if len(lowerCamelCase) > 0:
												# Fix an alleged bug [2] in the keep score computation.
												# keepscore_recall = keeptmpscore2 / len(keepgramcounterall_rep)
												__lowerCAmelCase							       =				keeptmpscorea / sum(keepgramcounterall_rep.values())
						__lowerCAmelCase							       =				0
						if keepscore_precision > 0 or keepscore_recall > 0:
												__lowerCAmelCase							       =				2 * keepscore_precision * keepscore_recall / (keepscore_precision + keepscore_recall)

						# DELETION
						__lowerCAmelCase							       =				sgramcounter_rep - cgramcounter_rep
						__lowerCAmelCase							       =				delgramcounter_rep - rgramcounter
						__lowerCAmelCase							       =				sgramcounter_rep - rgramcounter
						__lowerCAmelCase							       =				0
						__lowerCAmelCase							       =				0
						for delgram in delgramcountergood_rep:
												deltmpscorea += delgramcountergood_rep[delgram] / delgramcounter_rep[delgram]
												deltmpscorea += delgramcountergood_rep[delgram] / delgramcounterall_rep[delgram]
						# Define 0/0=1 instead of 0 to give higher scores for predictions that match
						# a target exactly.
						__lowerCAmelCase							       =				1
						if len(lowerCamelCase) > 0:
												__lowerCAmelCase							       =				deltmpscorea / len(lowerCamelCase)

						# ADDITION
						__lowerCAmelCase							       =				set(lowerCamelCase) - set(lowerCamelCase)
						__lowerCAmelCase							       =				set(lowerCamelCase) & set(lowerCamelCase)
						__lowerCAmelCase							       =				set(lowerCamelCase) - set(lowerCamelCase)

						__lowerCAmelCase							       =				0
						for addgram in addgramcountergood:
												addtmpscore += 1

						# Define 0/0=1 instead of 0 to give higher scores for predictions that match
						# a target exactly.
						__lowerCAmelCase							       =				1
						__lowerCAmelCase							       =				1
						if len(lowerCamelCase) > 0:
												__lowerCAmelCase							       =				addtmpscore / len(lowerCamelCase)
						if len(lowerCamelCase) > 0:
												__lowerCAmelCase							       =				addtmpscore / len(lowerCamelCase)
						__lowerCAmelCase							       =				0
						if addscore_precision > 0 or addscore_recall > 0:
												__lowerCAmelCase							       =				2 * addscore_precision * addscore_recall / (addscore_precision + addscore_recall)

						return (keepscore, delscore_precision, addscore)

def 							__magic_name__(						lowerCamelCase,				lowerCamelCase,				lowerCamelCase):
						__lowerCAmelCase							       =				len(lowerCamelCase)

						__lowerCAmelCase							       =				ssent.split(''' ''')
						__lowerCAmelCase							       =				csent.split(''' ''')
						__lowerCAmelCase							       =				[]
						__lowerCAmelCase							       =				[]
						__lowerCAmelCase							       =				[]
						__lowerCAmelCase							       =				[]
						__lowerCAmelCase							       =				[]
						__lowerCAmelCase							       =				[]

						__lowerCAmelCase							       =				[]
						__lowerCAmelCase							       =				[]
						__lowerCAmelCase							       =				[]
						__lowerCAmelCase							       =				[]
						for rsent in rsents:
												__lowerCAmelCase							       =				rsent.split(''' ''')
												__lowerCAmelCase							       =				[]
												__lowerCAmelCase							       =				[]
												__lowerCAmelCase							       =				[]
												ragramslist.append(lowerCamelCase)
												for i in range(0,				len(lowerCamelCase) - 1):
																		if i < len(lowerCamelCase) - 1:
																								__lowerCAmelCase							       =				ragrams[i] + ''' ''' + ragrams[i + 1]
																								ragrams.append(lowerCamelCase)
																		if i < len(lowerCamelCase) - 2:
																								__lowerCAmelCase							       =				ragrams[i] + ''' ''' + ragrams[i + 1] + ''' ''' + ragrams[i + 2]
																								ragrams.append(lowerCamelCase)
																		if i < len(lowerCamelCase) - 3:
																								__lowerCAmelCase							       =				ragrams[i] + ''' ''' + ragrams[i + 1] + ''' ''' + ragrams[i + 2] + ''' ''' + ragrams[i + 3]
																								ragrams.append(lowerCamelCase)
												ragramslist.append(lowerCamelCase)
												ragramslist.append(lowerCamelCase)
												ragramslist.append(lowerCamelCase)

						for i in range(0,				len(lowerCamelCase) - 1):
												if i < len(lowerCamelCase) - 1:
																		__lowerCAmelCase							       =				sagrams[i] + ''' ''' + sagrams[i + 1]
																		sagrams.append(lowerCamelCase)
												if i < len(lowerCamelCase) - 2:
																		__lowerCAmelCase							       =				sagrams[i] + ''' ''' + sagrams[i + 1] + ''' ''' + sagrams[i + 2]
																		sagrams.append(lowerCamelCase)
												if i < len(lowerCamelCase) - 3:
																		__lowerCAmelCase							       =				sagrams[i] + ''' ''' + sagrams[i + 1] + ''' ''' + sagrams[i + 2] + ''' ''' + sagrams[i + 3]
																		sagrams.append(lowerCamelCase)

						for i in range(0,				len(lowerCamelCase) - 1):
												if i < len(lowerCamelCase) - 1:
																		__lowerCAmelCase							       =				cagrams[i] + ''' ''' + cagrams[i + 1]
																		cagrams.append(lowerCamelCase)
												if i < len(lowerCamelCase) - 2:
																		__lowerCAmelCase							       =				cagrams[i] + ''' ''' + cagrams[i + 1] + ''' ''' + cagrams[i + 2]
																		cagrams.append(lowerCamelCase)
												if i < len(lowerCamelCase) - 3:
																		__lowerCAmelCase							       =				cagrams[i] + ''' ''' + cagrams[i + 1] + ''' ''' + cagrams[i + 2] + ''' ''' + cagrams[i + 3]
																		cagrams.append(lowerCamelCase)

						((__lowerCAmelCase)       ,					(__lowerCAmelCase)       ,					(__lowerCAmelCase))							       =				SARIngram(lowerCamelCase,				lowerCamelCase,				lowerCamelCase,				lowerCamelCase)
						((__lowerCAmelCase)       ,					(__lowerCAmelCase)       ,					(__lowerCAmelCase))							       =				SARIngram(lowerCamelCase,				lowerCamelCase,				lowerCamelCase,				lowerCamelCase)
						((__lowerCAmelCase)       ,					(__lowerCAmelCase)       ,					(__lowerCAmelCase))							       =				SARIngram(lowerCamelCase,				lowerCamelCase,				lowerCamelCase,				lowerCamelCase)
						((__lowerCAmelCase)       ,					(__lowerCAmelCase)       ,					(__lowerCAmelCase))							       =				SARIngram(lowerCamelCase,				lowerCamelCase,				lowerCamelCase,				lowerCamelCase)
						__lowerCAmelCase							       =				sum([keepascore, keepascore, keepascore, keepascore]) / 4
						__lowerCAmelCase							       =				sum([delascore, delascore, delascore, delascore]) / 4
						__lowerCAmelCase							       =				sum([addascore, addascore, addascore, addascore]) / 4
						__lowerCAmelCase							       =				(avgkeepscore + avgdelscore + avgaddscore) / 3
						return finalscore

def 							__magic_name__(						lowerCamelCase,				lowerCamelCase = True,				lowerCamelCase = "13a",				lowerCamelCase = True):
						# Normalization is requried for the ASSET dataset (one of the primary
						# datasets in sentence simplification) to allow using space
						# to split the sentence. Even though Wiki-Auto and TURK datasets,
						# do not require normalization, we do it for consistency.
						# Code adapted from the EASSE library [1] written by the authors of the ASSET dataset.
						# [1] https://github.com/feralvam/easse/blob/580bba7e1378fc8289c663f864e0487188fe8067/easse/utils/preprocessing.py#L7

						if lowercase:
												__lowerCAmelCase							       =				sentence.lower()

						if tokenizer in ["13a", "intl"]:
												if version.parse(sacrebleu.__version__).major >= 2:
																		__lowerCAmelCase							       =				sacrebleu.metrics.bleu._get_tokenizer(lowerCamelCase)()(lowerCamelCase)
												else:
																		__lowerCAmelCase							       =				sacrebleu.TOKENIZERS[tokenizer]()(lowerCamelCase)
						elif tokenizer == "moses":
												__lowerCAmelCase							       =				sacremoses.MosesTokenizer().tokenize(lowerCamelCase,				return_str=lowerCamelCase,				escape=lowerCamelCase)
						elif tokenizer == "penn":
												__lowerCAmelCase							       =				sacremoses.MosesTokenizer().penn_tokenize(lowerCamelCase,				return_str=lowerCamelCase)
						else:
												__lowerCAmelCase							       =				sentence

						if not return_str:
												__lowerCAmelCase							       =				normalized_sent.split()

						return normalized_sent

def 							__magic_name__(						lowerCamelCase,				lowerCamelCase,				lowerCamelCase):
						if not (len(lowerCamelCase) == len(lowerCamelCase) == len(lowerCamelCase)):
												raise ValueError('''Sources length must match predictions and references lengths.''')
						__lowerCAmelCase							       =				0
						for src, pred, refs in zip(lowerCamelCase,				lowerCamelCase,				lowerCamelCase):
												sari_score += SARIsent(normalize(lowerCamelCase),				normalize(lowerCamelCase),				[normalize(lowerCamelCase) for sent in refs])
						__lowerCAmelCase							       =				sari_score / len(lowerCamelCase)
						return 1_0_0 * sari_score

def 							__magic_name__(						lowerCamelCase,				lowerCamelCase,				lowerCamelCase="exp",				lowerCamelCase=None,				lowerCamelCase=False,				lowerCamelCase=False,				lowerCamelCase=False,				):
						__lowerCAmelCase							       =				len(references[0])
						if any(len(lowerCamelCase) != references_per_prediction for refs in references):
												raise ValueError('''Sacrebleu requires the same number of references for each prediction''')
						__lowerCAmelCase							       =				[[refs[i] for refs in references] for i in range(lowerCamelCase)]
						__lowerCAmelCase							       =				sacrebleu.corpus_bleu(
						    lowerCamelCase,				lowerCamelCase,				smooth_method=lowerCamelCase,				smooth_value=lowerCamelCase,				force=lowerCamelCase,				lowercase=lowerCamelCase,				use_effective_order=lowerCamelCase,				)
						return output.score




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







				"""simple docstring"""



				def 					_snake_case  (self		):
										return datasets.MetricInfo(
										    description=_DESCRIPTION       ,			citation=_CITATION       ,			inputs_description=_KWARGS_DESCRIPTION       ,			features=datasets.Features(
										        {
										            '''predictions''': datasets.Value('''string'''       ,			id='''sequence'''		),
										            '''references''': datasets.Sequence(datasets.Value('''string'''       ,			id='''sequence'''		)       ,			id='''references'''		),
										        }		)       ,			codebase_urls=[
										        '''https://github.com/huggingface/transformers/blob/master/src/transformers/data/metrics/squad_metrics.py''',
										        '''https://github.com/cocoxu/simplification/blob/master/SARI.py''',
										        '''https://github.com/tensorflow/tensor2tensor/blob/master/tensor2tensor/utils/sari_hook.py''',
										        '''https://github.com/mjpost/sacreBLEU''',
										    ]       ,			reference_urls=[
										        '''https://www.aclweb.org/anthology/Q16-1029.pdf''',
										        '''https://github.com/mjpost/sacreBLEU''',
										        '''https://en.wikipedia.org/wiki/BLEU''',
										        '''https://towardsdatascience.com/evaluating-text-output-in-nlp-bleu-at-your-own-risk-e8609665a213''',
										    ]       ,			)




				def 					_snake_case  (self       ,			__lowercase       ,			__lowercase       ,			__lowercase		):
										__lowerCAmelCase							       =				{}
										result.update({'''sari''': compute_sari(sources=__lowercase       ,			predictions=__lowercase       ,			references=__lowercase		)}		)
										result.update({'''sacrebleu''': compute_sacrebleu(predictions=__lowercase       ,			references=__lowercase		)}		)
										result.update({'''exact''': compute_em(predictions=__lowercase       ,			references=__lowercase		)}		)
										return result





'''simple docstring'''

from math import asin, atan, cos, radians, sin, sqrt, tan

_UpperCAmelCase				: str							    =				6_37_81_37.0
_UpperCAmelCase				: Tuple							    =				6_35_67_52.31_42_45
_UpperCAmelCase				: Optional[Any]							    =				6_3_7_8_1_3_7

def 							__magic_name__(						lowerCamelCase,				lowerCamelCase,				lowerCamelCase,				lowerCamelCase):
						__lowerCAmelCase							       =				(AXIS_A - AXIS_B) / AXIS_A
						__lowerCAmelCase							       =				atan((1 - flattening) * tan(radians(lowerCamelCase)))
						__lowerCAmelCase							       =				atan((1 - flattening) * tan(radians(lowerCamelCase)))
						__lowerCAmelCase							       =				radians(lowerCamelCase)
						__lowerCAmelCase							       =				radians(lowerCamelCase)
						# Equation
						__lowerCAmelCase							       =				sin((phi_a - phi_a) / 2)
						__lowerCAmelCase							       =				sin((lambda_a - lambda_a) / 2)
						# Square both values
						sin_sq_phi *= sin_sq_phi
						sin_sq_lambda *= sin_sq_lambda
						__lowerCAmelCase							       =				sqrt(sin_sq_phi + (cos(lowerCamelCase) * cos(lowerCamelCase) * sin_sq_lambda))
						return 2 * RADIUS * asin(lowerCamelCase)


if __name__ == "__main__":
	import doctest

	doctest.testmod()

