





"""simple docstring"""





import re
import string
from collections import Counter

import sacrebleu
import sacremoses
from packaging import version

import datasets


lowerCAmelCase__     			=			'''
@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",
}
'''

lowerCAmelCase__     			=			'''\
WIKI_SPLIT is the combination of three metrics SARI, EXACT and SACREBLEU
It can be used to evaluate the quality of machine-generated texts.
'''


lowerCAmelCase__     			=			'''
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       a__					(					_SCREAMING_SNAKE_CASE    ):




		"""simple docstring"""


		def remove_articles(_SCREAMING_SNAKE_CASE    ):
				UpperCamelCase   =	re.compile(r"\b(a|an|the)\b"  ,	re.UNICODE    )
				return re.sub(_SCREAMING_SNAKE_CASE  ,	" "  ,	_SCREAMING_SNAKE_CASE    )

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

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

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

		return white_space_fix(remove_articles(remove_punc(lower(_SCREAMING_SNAKE_CASE    )    )    )    )


def       a__					(					_SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE    ):




		"""simple docstring"""


		return int(normalize_answer(_SCREAMING_SNAKE_CASE    ) == normalize_answer(_SCREAMING_SNAKE_CASE    )    )


def       a__					(					_SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE    ):




		"""simple docstring"""


		UpperCamelCase   =	[any(compute_exact(_SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE    ) for ref in refs    ) for pred, refs in zip(_SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE    )]
		return (sum(_SCREAMING_SNAKE_CASE    ) / len(_SCREAMING_SNAKE_CASE    )) * 100


def       a__					(					_SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE    ):




		"""simple docstring"""


		UpperCamelCase   =	[rgram for rgrams in rgramslist for rgram in rgrams]
		UpperCamelCase   =	Counter(_SCREAMING_SNAKE_CASE    )

		UpperCamelCase   =	Counter(_SCREAMING_SNAKE_CASE    )
		UpperCamelCase   =	Counter()
		for sgram, scount in sgramcounter.items():
				UpperCamelCase   =	scount * numref

		UpperCamelCase   =	Counter(_SCREAMING_SNAKE_CASE    )
		UpperCamelCase   =	Counter()
		for cgram, ccount in cgramcounter.items():
				UpperCamelCase   =	ccount * numref

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

		UpperCamelCase   =	0
		UpperCamelCase   =	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.
		UpperCamelCase   =	1
		UpperCamelCase   =	1
		if len(_SCREAMING_SNAKE_CASE    ) > 0:
				UpperCamelCase   =	keeptmpscorea / len(_SCREAMING_SNAKE_CASE    )
		if len(_SCREAMING_SNAKE_CASE    ) > 0:
				# Fix an alleged bug [2] in the keep score computation.
				# keepscore_recall = keeptmpscore2 / len(keepgramcounterall_rep)
				UpperCamelCase   =	keeptmpscorea / sum(keepgramcounterall_rep.values()    )
		UpperCamelCase   =	0
		if keepscore_precision > 0 or keepscore_recall > 0:
				UpperCamelCase   =	2 * keepscore_precision * keepscore_recall / (keepscore_precision + keepscore_recall)

		# DELETION
		UpperCamelCase   =	sgramcounter_rep - cgramcounter_rep
		UpperCamelCase   =	delgramcounter_rep - rgramcounter
		UpperCamelCase   =	sgramcounter_rep - rgramcounter
		UpperCamelCase   =	0
		UpperCamelCase   =	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.
		UpperCamelCase   =	1
		if len(_SCREAMING_SNAKE_CASE    ) > 0:
				UpperCamelCase   =	deltmpscorea / len(_SCREAMING_SNAKE_CASE    )

		# ADDITION
		UpperCamelCase   =	set(_SCREAMING_SNAKE_CASE    ) - set(_SCREAMING_SNAKE_CASE    )
		UpperCamelCase   =	set(_SCREAMING_SNAKE_CASE    ) & set(_SCREAMING_SNAKE_CASE    )
		UpperCamelCase   =	set(_SCREAMING_SNAKE_CASE    ) - set(_SCREAMING_SNAKE_CASE    )

		UpperCamelCase   =	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.
		UpperCamelCase   =	1
		UpperCamelCase   =	1
		if len(_SCREAMING_SNAKE_CASE    ) > 0:
				UpperCamelCase   =	addtmpscore / len(_SCREAMING_SNAKE_CASE    )
		if len(_SCREAMING_SNAKE_CASE    ) > 0:
				UpperCamelCase   =	addtmpscore / len(_SCREAMING_SNAKE_CASE    )
		UpperCamelCase   =	0
		if addscore_precision > 0 or addscore_recall > 0:
				UpperCamelCase   =	2 * addscore_precision * addscore_recall / (addscore_precision + addscore_recall)

		return (keepscore, delscore_precision, addscore)


def       a__					(					_SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE    ):




		"""simple docstring"""


		UpperCamelCase   =	len(_SCREAMING_SNAKE_CASE    )

		UpperCamelCase   =	ssent.split(" "    )
		UpperCamelCase   =	csent.split(" "    )
		UpperCamelCase   =	[]
		UpperCamelCase   =	[]
		UpperCamelCase   =	[]
		UpperCamelCase   =	[]
		UpperCamelCase   =	[]
		UpperCamelCase   =	[]

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

		for i in range(0  ,	len(_SCREAMING_SNAKE_CASE    ) - 1    ):
				if i < len(_SCREAMING_SNAKE_CASE    ) - 1:
						UpperCamelCase   =	sagrams[i] + " " + sagrams[i + 1]
						sagrams.append(_SCREAMING_SNAKE_CASE    )
				if i < len(_SCREAMING_SNAKE_CASE    ) - 2:
						UpperCamelCase   =	sagrams[i] + " " + sagrams[i + 1] + " " + sagrams[i + 2]
						sagrams.append(_SCREAMING_SNAKE_CASE    )
				if i < len(_SCREAMING_SNAKE_CASE    ) - 3:
						UpperCamelCase   =	sagrams[i] + " " + sagrams[i + 1] + " " + sagrams[i + 2] + " " + sagrams[i + 3]
						sagrams.append(_SCREAMING_SNAKE_CASE    )

		for i in range(0  ,	len(_SCREAMING_SNAKE_CASE    ) - 1    ):
				if i < len(_SCREAMING_SNAKE_CASE    ) - 1:
						UpperCamelCase   =	cagrams[i] + " " + cagrams[i + 1]
						cagrams.append(_SCREAMING_SNAKE_CASE    )
				if i < len(_SCREAMING_SNAKE_CASE    ) - 2:
						UpperCamelCase   =	cagrams[i] + " " + cagrams[i + 1] + " " + cagrams[i + 2]
						cagrams.append(_SCREAMING_SNAKE_CASE    )
				if i < len(_SCREAMING_SNAKE_CASE    ) - 3:
						UpperCamelCase   =	cagrams[i] + " " + cagrams[i + 1] + " " + cagrams[i + 2] + " " + cagrams[i + 3]
						cagrams.append(_SCREAMING_SNAKE_CASE    )

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


def       a__					(					_SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE = True  ,	_SCREAMING_SNAKE_CASE = "13a"  ,	_SCREAMING_SNAKE_CASE = True    ):




		"""simple docstring"""


		if lowercase:
				UpperCamelCase   =	sentence.lower()

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

		if not return_str:
				UpperCamelCase   =	normalized_sent.split()

		return normalized_sent


def       a__					(					_SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE    ):




		"""simple docstring"""


		if not (len(_SCREAMING_SNAKE_CASE    ) == len(_SCREAMING_SNAKE_CASE    ) == len(_SCREAMING_SNAKE_CASE    )):
				raise ValueError("Sources length must match predictions and references lengths."    )
		UpperCamelCase   =	0
		for src, pred, refs in zip(_SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE    ):
				sari_score += SARIsent(normalize(_SCREAMING_SNAKE_CASE    )  ,	normalize(_SCREAMING_SNAKE_CASE    )  ,	[normalize(_SCREAMING_SNAKE_CASE    ) for sent in refs]    )
		UpperCamelCase   =	sari_score / len(_SCREAMING_SNAKE_CASE    )
		return 100 * sari_score


def       a__					(					_SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE="exp"  ,	_SCREAMING_SNAKE_CASE=None  ,	_SCREAMING_SNAKE_CASE=False  ,	_SCREAMING_SNAKE_CASE=False  ,	_SCREAMING_SNAKE_CASE=False  ,	):




		"""simple docstring"""


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






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


						def     snake_case_   (self		) ->   Optional[Any]:
								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   ,							__a   ,							__a   ,							__a		) ->   Tuple:
								UpperCamelCase   =	{}
								result.update({"sari": compute_sari(sources=__a   ,							predictions=__a   ,							references=__a		)}		)
								result.update({"sacrebleu": compute_sacrebleu(predictions=__a   ,							references=__a		)}		)
								result.update({"exact": compute_em(predictions=__a   ,							references=__a		)}		)
								return result













"""simple docstring"""





def       a__					(					_SCREAMING_SNAKE_CASE    ):




		"""simple docstring"""


		UpperCamelCase   =	0
		for ch in input_str:
				UpperCamelCase   =	ord(_SCREAMING_SNAKE_CASE    )
				UpperCamelCase   =	pow(2  ,	_SCREAMING_SNAKE_CASE    )

				# If we already turned on bit for current character's unicode
				if bitmap >> ch_unicode & 1 == 1:
						return False
				bitmap |= ch_bit_index_on
		return True


if __name__ == "__main__":
						import doctest

						doctest.testmod()






