


"""simple docstring"""







import re
import string
from collections import Counter

import sacrebleu
import sacremoses
from packaging import version

import datasets


a__    :							Any            =					'''
@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",
}
'''

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


a__    :							Tuple            =					'''
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        UpperCAmelCase__	(lowerCAmelCase_       ):




					'''simple docstring'''


					def remove_articles(lowerCAmelCase_       ):
										__SCREAMING_SNAKE_CASE						       =    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_       ):
										__SCREAMING_SNAKE_CASE						       =    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        UpperCAmelCase__	(lowerCAmelCase_  ,						lowerCAmelCase_       ):




					'''simple docstring'''


					return int(normalize_answer(lowerCAmelCase_       ) == normalize_answer(lowerCAmelCase_       )       )




def        UpperCAmelCase__	(lowerCAmelCase_  ,						lowerCAmelCase_       ):




					'''simple docstring'''


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




def        UpperCAmelCase__	(lowerCAmelCase_  ,						lowerCAmelCase_  ,						lowerCAmelCase_  ,						lowerCAmelCase_       ):




					'''simple docstring'''


					__SCREAMING_SNAKE_CASE						       =    [rgram for rgrams in rgramslist for rgram in rgrams]
					__SCREAMING_SNAKE_CASE						       =    Counter(lowerCAmelCase_       )

					__SCREAMING_SNAKE_CASE						       =    Counter(lowerCAmelCase_       )
					__SCREAMING_SNAKE_CASE						       =    Counter()
					for sgram, scount in sgramcounter.items():
										__SCREAMING_SNAKE_CASE						       =    scount * numref

					__SCREAMING_SNAKE_CASE						       =    Counter(lowerCAmelCase_       )
					__SCREAMING_SNAKE_CASE						       =    Counter()
					for cgram, ccount in cgramcounter.items():
										__SCREAMING_SNAKE_CASE						       =    ccount * numref

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

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

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

					# ADDITION
					__SCREAMING_SNAKE_CASE						       =    set(lowerCAmelCase_       ) - set(lowerCAmelCase_       )
					__SCREAMING_SNAKE_CASE						       =    set(lowerCAmelCase_       ) & set(lowerCAmelCase_       )
					__SCREAMING_SNAKE_CASE						       =    set(lowerCAmelCase_       ) - set(lowerCAmelCase_       )

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

					return (keepscore, delscore_precision, addscore)




def        UpperCAmelCase__	(lowerCAmelCase_  ,						lowerCAmelCase_  ,						lowerCAmelCase_       ):




					'''simple docstring'''


					__SCREAMING_SNAKE_CASE						       =    len(lowerCAmelCase_       )

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

					__SCREAMING_SNAKE_CASE						       =    []
					__SCREAMING_SNAKE_CASE						       =    []
					__SCREAMING_SNAKE_CASE						       =    []
					__SCREAMING_SNAKE_CASE						       =    []
					for rsent in rsents:
										__SCREAMING_SNAKE_CASE						       =    rsent.split(" "       )
										__SCREAMING_SNAKE_CASE						       =    []
										__SCREAMING_SNAKE_CASE						       =    []
										__SCREAMING_SNAKE_CASE						       =    []
										ragramslist.append(lowerCAmelCase_       )
										for i in range(0  ,						len(lowerCAmelCase_       ) - 1       ):
															if i < len(lowerCAmelCase_       ) - 1:
																				__SCREAMING_SNAKE_CASE						       =    ragrams[i] + " " + ragrams[i + 1]
																				ragrams.append(lowerCAmelCase_       )
															if i < len(lowerCAmelCase_       ) - 2:
																				__SCREAMING_SNAKE_CASE						       =    ragrams[i] + " " + ragrams[i + 1] + " " + ragrams[i + 2]
																				ragrams.append(lowerCAmelCase_       )
															if i < len(lowerCAmelCase_       ) - 3:
																				__SCREAMING_SNAKE_CASE						       =    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:
															__SCREAMING_SNAKE_CASE						       =    sagrams[i] + " " + sagrams[i + 1]
															sagrams.append(lowerCAmelCase_       )
										if i < len(lowerCAmelCase_       ) - 2:
															__SCREAMING_SNAKE_CASE						       =    sagrams[i] + " " + sagrams[i + 1] + " " + sagrams[i + 2]
															sagrams.append(lowerCAmelCase_       )
										if i < len(lowerCAmelCase_       ) - 3:
															__SCREAMING_SNAKE_CASE						       =    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:
															__SCREAMING_SNAKE_CASE						       =    cagrams[i] + " " + cagrams[i + 1]
															cagrams.append(lowerCAmelCase_       )
										if i < len(lowerCAmelCase_       ) - 2:
															__SCREAMING_SNAKE_CASE						       =    cagrams[i] + " " + cagrams[i + 1] + " " + cagrams[i + 2]
															cagrams.append(lowerCAmelCase_       )
										if i < len(lowerCAmelCase_       ) - 3:
															__SCREAMING_SNAKE_CASE						       =    cagrams[i] + " " + cagrams[i + 1] + " " + cagrams[i + 2] + " " + cagrams[i + 3]
															cagrams.append(lowerCAmelCase_       )

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




def        UpperCAmelCase__	(lowerCAmelCase_  ,						lowerCAmelCase_ = True  ,						lowerCAmelCase_ = "13a"  ,						lowerCAmelCase_ = True       ):




					'''simple docstring'''


					if lowercase:
										__SCREAMING_SNAKE_CASE						       =    sentence.lower()

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

					if not return_str:
										__SCREAMING_SNAKE_CASE						       =    normalized_sent.split()

					return normalized_sent




def        UpperCAmelCase__	(lowerCAmelCase_  ,						lowerCAmelCase_  ,						lowerCAmelCase_       ):




					'''simple docstring'''


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




def        UpperCAmelCase__	(lowerCAmelCase_  ,						lowerCAmelCase_  ,						lowerCAmelCase_="exp"  ,						lowerCAmelCase_=None  ,						lowerCAmelCase_=False  ,						lowerCAmelCase_=False  ,						lowerCAmelCase_=False  ,						):




					'''simple docstring'''


					__SCREAMING_SNAKE_CASE						       =    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"       )
					__SCREAMING_SNAKE_CASE						       =    [[refs[i] for refs in references] for i in range(lowerCAmelCase_       )]
					__SCREAMING_SNAKE_CASE						       =    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 			UpperCamelCase_     (			datasets.Metric):

	"""simple docstring"""





	def   UpperCAmelCase_				(			self      :    str       )	->     Tuple:
						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   UpperCAmelCase_				(			self      :    List[Any]      ,      UpperCAmelCase__      :    List[Any]      ,      UpperCAmelCase__      :    int      ,      UpperCAmelCase__      :    List[str]       )	->     str:
						__SCREAMING_SNAKE_CASE						       =    {}
						result.update({"sari": compute_sari(sources=UpperCAmelCase__      ,      predictions=UpperCAmelCase__      ,      references=UpperCAmelCase__       )}       )
						result.update({"sacrebleu": compute_sacrebleu(predictions=UpperCAmelCase__      ,      references=UpperCAmelCase__       )}       )
						result.update({"exact": compute_em(predictions=UpperCAmelCase__      ,      references=UpperCAmelCase__       )}       )
						return result




"""simple docstring"""







a__    :							Optional[Any]            =					'''ABCDEFGHIJKLMNOPQRSTUVWXYZ'''




def        UpperCAmelCase__	():




					'''simple docstring'''


					__SCREAMING_SNAKE_CASE						       =    input("Enter message: "       )
					__SCREAMING_SNAKE_CASE						       =    input("Enter key [alphanumeric]: "       )
					__SCREAMING_SNAKE_CASE						       =    input("Encrypt/Decrypt [e/d]: "       )

					if mode.lower().startswith("e"       ):
										__SCREAMING_SNAKE_CASE						       =    "encrypt"
										__SCREAMING_SNAKE_CASE						       =    encrypt_message(lowerCAmelCase_  ,						lowerCAmelCase_       )
					elif mode.lower().startswith("d"       ):
										__SCREAMING_SNAKE_CASE						       =    "decrypt"
										__SCREAMING_SNAKE_CASE						       =    decrypt_message(lowerCAmelCase_  ,						lowerCAmelCase_       )

					print(f"""\n{mode.title()}ed message:"""       )
					print(lowerCAmelCase_       )




def        UpperCAmelCase__	(lowerCAmelCase_  ,						lowerCAmelCase_       ):




					'''simple docstring'''


					return translate_message(lowerCAmelCase_  ,						lowerCAmelCase_  ,						"encrypt"       )




def        UpperCAmelCase__	(lowerCAmelCase_  ,						lowerCAmelCase_       ):




					'''simple docstring'''


					return translate_message(lowerCAmelCase_  ,						lowerCAmelCase_  ,						"decrypt"       )




def        UpperCAmelCase__	(lowerCAmelCase_  ,						lowerCAmelCase_  ,						lowerCAmelCase_       ):




					'''simple docstring'''


					__SCREAMING_SNAKE_CASE						       =    []
					__SCREAMING_SNAKE_CASE						       =    0
					__SCREAMING_SNAKE_CASE						       =    key.upper()

					for symbol in message:
										__SCREAMING_SNAKE_CASE						       =    LETTERS.find(symbol.upper()       )
										if num != -1:
															if mode == "encrypt":
																				num += LETTERS.find(key[key_index]       )
															elif mode == "decrypt":
																				num -= LETTERS.find(key[key_index]       )

															num %= len(lowerCAmelCase_       )

															if symbol.isupper():
																				translated.append(LETTERS[num]       )
															elif symbol.islower():
																				translated.append(LETTERS[num].lower()       )

															key_index += 1
															if key_index == len(lowerCAmelCase_       ):
																				__SCREAMING_SNAKE_CASE						       =    0
										else:
															translated.append(lowerCAmelCase_       )
					return "".join(lowerCAmelCase_       )


if __name__ == "__main__":
		main()
