


'''simple docstring'''
from typing import List

from packaging import version
from sklearn.metrics import fa_score

import datasets
from datasets.config import PY_VERSION


if PY_VERSION < version.parse('3.8'):
						import importlib_metadata
else:
						import importlib.metadata as importlib_metadata


# TODO(Patrick/Anton)
__magic_name__   :   Optional[Any]  							='\\n'

__magic_name__   :   str  							='\\n    XTREME-S is a benchmark to evaluate universal cross-lingual speech representations in many languages.\n    XTREME-S covers four task families: speech recognition, classification, speech-to-text translation and retrieval.\n'

__magic_name__   :   Any  							='\nCompute XTREME-S evaluation metric associated to each XTREME-S dataset.\nArgs:\n    predictions: list of predictions to score.\n        Each translation should be tokenized into a list of tokens.\n    references: list of lists of references for each translation.\n        Each reference should be tokenized into a list of tokens.\n    bleu_kwargs: optional dict of keywords to be passed when computing \'bleu\'.\n        Keywords include Dict can be one of \'smooth_method\', \'smooth_value\', \'force\', \'lowercase\',\n        \'tokenize\', \'use_effective_order\'.\n    wer_kwargs: optional dict of keywords to be passed when computing \'wer\' and \'cer\'.\n        Keywords include \'concatenate_texts\'.\nReturns: depending on the XTREME-S task, one or several of:\n    "accuracy": Accuracy - for \'fleurs-lang_id\', \'minds14\'\n    "f1": F1 score - for \'minds14\'\n    "wer": Word error rate - for \'mls\', \'fleurs-asr\', \'voxpopuli\', \'babel\'\n    "cer": Character error rate - for \'mls\', \'fleurs-asr\', \'voxpopuli\', \'babel\'\n    "bleu": BLEU score according to the `sacrebleu` metric - for \'covost2\'\nExamples:\n\n    >>> xtreme_s_metric = datasets.load_metric(\'xtreme_s\', \'mls\')  # \'mls\', \'voxpopuli\', \'fleurs-asr\' or \'babel\'\n    >>> references = ["it is sunny here", "paper and pen are essentials"]\n    >>> predictions = ["it\'s sunny", "paper pen are essential"]\n    >>> results = xtreme_s_metric.compute(predictions=predictions, references=references)\n    >>> print({k: round(v, 2) for k, v in results.items()})\n    {\'wer\': 0.56, \'cer\': 0.27}\n\n    >>> xtreme_s_metric = datasets.load_metric(\'xtreme_s\', \'covost2\')\n    >>> references = ["bonjour paris", "il est necessaire de faire du sport de temps en temp"]\n    >>> predictions = ["bonjour paris", "il est important de faire du sport souvent"]\n    >>> results = xtreme_s_metric.compute(predictions=predictions, references=references)\n    >>> print({k: round(v, 2) for k, v in results.items()})\n    {\'bleu\': 31.65}\n\n    >>> xtreme_s_metric = datasets.load_metric(\'xtreme_s\', \'fleurs-lang_id\')\n    >>> references = [0, 1, 0, 0, 1]\n    >>> predictions = [0, 1, 1, 0, 0]\n    >>> results = xtreme_s_metric.compute(predictions=predictions, references=references)\n    >>> print({k: round(v, 2) for k, v in results.items()})\n    {\'accuracy\': 0.6}\n\n    >>> xtreme_s_metric = datasets.load_metric(\'xtreme_s\', \'minds14\')\n    >>> references = [0, 1, 0, 0, 1]\n    >>> predictions = [0, 1, 1, 0, 0]\n    >>> results = xtreme_s_metric.compute(predictions=predictions, references=references)\n    >>> print({k: round(v, 2) for k, v in results.items()})\n    {\'f1\': 0.58, \'accuracy\': 0.6}\n'

__magic_name__   :   Any  							=['fleurs-asr', 'mls', 'voxpopuli', 'babel', 'covost2', 'fleurs-lang_id', 'minds14']
__magic_name__   :   str  							=''

try:
						from jiwer import transforms as tr

						__magic_name__   :   Optional[Any]  							=True
except ImportError:
						__magic_name__   :   List[Any]  							=False

if _jiwer_available and version.parse(importlib_metadata.version('jiwer')) < version.parse('2.3.0'):






						class 		UpperCamelCase_		(					tr.AbstractTransform   ):





												"""simple docstring"""




												def __init__( self				:					int	,				_lowerCamelCase				:					str = " "  )							->					List[Any]:
																__magic_name__	  = sentence_delimiter
												def 					__A					( self				:					Optional[Any]	,				_lowerCamelCase				:					str  )							->					Dict:
																return list(_lowerCamelCase  )

												def 					__A					( self				:					Optional[Any]	,				_lowerCamelCase				:					List[str]  )							->					Any:
																__magic_name__	  = []
																for sent_idx, sentence in enumerate(_lowerCamelCase  ):
																				chars.extend(self.process_string(_lowerCamelCase  )  )
																				if self.sentence_delimiter is not None and self.sentence_delimiter != "" and sent_idx < len(_lowerCamelCase  ) - 1:
																								chars.append(self.sentence_delimiter  )
																return chars





						__magic_name__   :   Optional[Any]  							=tr.Compose(
						    [tr.RemoveMultipleSpaces(), tr.Strip(), SentencesToListOfCharacters(SENTENCE_DELIMITER)]
						)
elif _jiwer_available:
						__magic_name__   :   int  							=tr.Compose(
						    [
						        tr.RemoveMultipleSpaces(),
						        tr.Strip(),
						        tr.ReduceToSingleSentence(SENTENCE_DELIMITER),
						        tr.ReduceToListOfListOfChars(),
						    ]
						)
else:
						__magic_name__   :   Any  							=None




def      __snake_case       (       lowerCamelCase_ :				Optional[Any]	,  lowerCamelCase_ :				Union[str, Any]						):
				'''simple docstring'''




				return float((preds == labels).mean()						)




def      __snake_case       (       lowerCamelCase_ :				Optional[int]	,  lowerCamelCase_ :				List[Any]						):
				'''simple docstring'''




				return {
				    "f1": float(fa_score(y_true=lowerCamelCase_	,  y_pred=lowerCamelCase_	,  average="macro"						)						),
				    "accuracy": simple_accuracy(lowerCamelCase_	,  lowerCamelCase_						),
				}




def      __snake_case       (       lowerCamelCase_ :				str	,  lowerCamelCase_ :				str	,  lowerCamelCase_ :				Any="exp"	,  lowerCamelCase_ :				str=None	,  lowerCamelCase_ :				Union[str, Any]=False	,  lowerCamelCase_ :				Optional[int]=False	,  lowerCamelCase_ :				Tuple=None	,  lowerCamelCase_ :				int=False	,  ):
				'''simple docstring'''




				__magic_name__	  = [[label] for label in labels]
				__magic_name__	  = list(lowerCamelCase_						)
				try:
								import sacrebleu as scb
				except ImportError:
								raise ValueError(
								    "sacrebleu has to be installed in order to apply the bleu metric for covost2."
								    "You can install it via `pip install sacrebleu`."						)

				if version.parse(scb.__version__						) < version.parse("1.4.12"						):
								raise ImportWarning(
								    "To use `sacrebleu`, the module `sacrebleu>=1.4.12` is required, and the current version of `sacrebleu` doesn't match this condition.\n"
								    "You can install it with `pip install \"sacrebleu>=1.4.12\"`."						)

				__magic_name__	  = len(labels[0]						)
				if any(len(lowerCamelCase_						) != references_per_prediction for refs in labels						):
								raise ValueError("Sacrebleu requires the same number of references for each prediction"						)
				__magic_name__	  = [[refs[i] for refs in labels] for i in range(lowerCamelCase_						)]
				__magic_name__	  = scb.corpus_bleu(
				    lowerCamelCase_	,  lowerCamelCase_	,  smooth_method=lowerCamelCase_	,  smooth_value=lowerCamelCase_	,  force=lowerCamelCase_	,  lowercase=lowerCamelCase_	,  use_effective_order=lowerCamelCase_	,  **({"tokenize": tokenize} if tokenize else {})	,  )
				return {"bleu": output.score}




def      __snake_case       (       lowerCamelCase_ :				Dict	,  lowerCamelCase_ :				Union[str, Any]	,  lowerCamelCase_ :				List[Any]	,  lowerCamelCase_ :				Optional[Any]						):
				'''simple docstring'''




				try:
								from jiwer import compute_measures
				except ImportError:
								raise ValueError(
								    F'jiwer has to be installed in order to apply the wer metric for {config_name}.'
								    "You can install it via `pip install jiwer`."						)

				if concatenate_texts:
								__magic_name__	  = compute_measures(lowerCamelCase_	,  lowerCamelCase_						)["wer"]

								__magic_name__	  = compute_measures(lowerCamelCase_	,  lowerCamelCase_	,  truth_transform=lowerCamelCase_	,  hypothesis_transform=lowerCamelCase_						)["wer"]
								return {"wer": wer, "cer": cer}
				else:

								def compute_score(lowerCamelCase_ :				Optional[Any]	,  lowerCamelCase_ :				List[Any]	,  lowerCamelCase_ :				List[str]="wer"						):
												__magic_name__	  = 0
												__magic_name__	  = 0
												for prediction, reference in zip(lowerCamelCase_	,  lowerCamelCase_						):
																if score_type == "wer":
																				__magic_name__	  = compute_measures(lowerCamelCase_	,  lowerCamelCase_						)
																elif score_type == "cer":
																				__magic_name__	  = compute_measures(
																				    lowerCamelCase_	,  lowerCamelCase_	,  truth_transform=lowerCamelCase_	,  hypothesis_transform=lowerCamelCase_						)
																incorrect += measures["substitutions"] + measures["deletions"] + measures["insertions"]
																total += measures["substitutions"] + measures["deletions"] + measures["hits"]
												return incorrect / total

								return {"wer": compute_score(lowerCamelCase_	,  lowerCamelCase_	,  "wer"						), "cer": compute_score(lowerCamelCase_	,  lowerCamelCase_	,  "cer"						)}






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





						"""simple docstring"""




						def 					__A					( self				:					Dict  )							->					Tuple:
										if self.config_name not in _CONFIG_NAMES:
														raise KeyError(f'You should supply a configuration name selected in {_CONFIG_NAMES}'  )

										__magic_name__	  = "int64" if self.config_name in ["fleurs-lang_id", "minds14"] else "string"

										return datasets.MetricInfo(
										    description=_DESCRIPTION	,				citation=_CITATION	,				inputs_description=_KWARGS_DESCRIPTION	,				features=datasets.Features(
										        {"predictions": datasets.Value(_lowerCamelCase  ), "references": datasets.Value(_lowerCamelCase  )}  )	,				codebase_urls=[]	,				reference_urls=[]	,				format="numpy"	,				)

						def 					__A					( self				:					str	,				_lowerCamelCase				:					Union[str, Any]	,				_lowerCamelCase				:					Optional[int]	,				_lowerCamelCase				:					Union[str, Any]=None	,				_lowerCamelCase				:					List[Any]=None  )							->					List[Any]:
										__magic_name__	  = bleu_kwargs if bleu_kwargs is not None else {}
										__magic_name__	  = wer_kwargs if wer_kwargs is not None else {}

										if self.config_name == "fleurs-lang_id":
														return {"accuracy": simple_accuracy(_lowerCamelCase	,				_lowerCamelCase  )}
										elif self.config_name == "minds14":
														return fa_and_simple_accuracy(_lowerCamelCase	,				_lowerCamelCase  )
										elif self.config_name == "covost2":
														__magic_name__	  = bleu_kwargs.pop("smooth_method"	,				"exp"  )
														__magic_name__	  = bleu_kwargs.pop("smooth_value"	,				_lowerCamelCase  )
														__magic_name__	  = bleu_kwargs.pop("force"	,				_lowerCamelCase  )
														__magic_name__	  = bleu_kwargs.pop("lowercase"	,				_lowerCamelCase  )
														__magic_name__	  = bleu_kwargs.pop("tokenize"	,				_lowerCamelCase  )
														__magic_name__	  = bleu_kwargs.pop("use_effective_order"	,				_lowerCamelCase  )
														return bleu(
														    preds=_lowerCamelCase	,				labels=_lowerCamelCase	,				smooth_method=_lowerCamelCase	,				smooth_value=_lowerCamelCase	,				force=_lowerCamelCase	,				lowercase=_lowerCamelCase	,				tokenize=_lowerCamelCase	,				use_effective_order=_lowerCamelCase	,				)
										elif self.config_name in ["fleurs-asr", "mls", "voxpopuli", "babel"]:
														__magic_name__	  = wer_kwargs.pop("concatenate_texts"	,				_lowerCamelCase  )
														return wer_and_cer(_lowerCamelCase	,				_lowerCamelCase	,				_lowerCamelCase	,				self.config_name  )
										else:
														raise KeyError(f'You should supply a configuration name selected in {_CONFIG_NAMES}'  )







'''simple docstring'''
import random
import sys

__magic_name__   :   Optional[Any]  							='ABCDEFGHIJKLMNOPQRSTUVWXYZ'




def      __snake_case       (       ):
				'''simple docstring'''




				__magic_name__	  = input("Enter message: "						)
				__magic_name__	  = "LFWOAYUISVKMNXPBDCRJTQEGHZ"
				__magic_name__	  = input("Encrypt/Decrypt [e/d]: "						)

				check_valid_key(lowerCamelCase_						)

				if resp.lower().startswith("e"						):
								__magic_name__	  = "encrypt"
								__magic_name__	  = encrypt_message(lowerCamelCase_	,  lowerCamelCase_						)
				elif resp.lower().startswith("d"						):
								__magic_name__	  = "decrypt"
								__magic_name__	  = decrypt_message(lowerCamelCase_	,  lowerCamelCase_						)

				print(F'\n{mode.title()}ion: \n{translated}'						)




def      __snake_case       (       lowerCamelCase_ :				str						):
				'''simple docstring'''




				__magic_name__	  = list(lowerCamelCase_						)
				__magic_name__	  = list(lowerCamelCase_						)
				key_list.sort()
				letters_list.sort()

				if key_list != letters_list:
								sys.exit("Error in the key or symbol set."						)




def      __snake_case       (       lowerCamelCase_ :				str	,  lowerCamelCase_ :				str						):
				'''simple docstring'''




				return translate_message(lowerCamelCase_	,  lowerCamelCase_	,  "encrypt"						)




def      __snake_case       (       lowerCamelCase_ :				str	,  lowerCamelCase_ :				str						):
				'''simple docstring'''




				return translate_message(lowerCamelCase_	,  lowerCamelCase_	,  "decrypt"						)




def      __snake_case       (       lowerCamelCase_ :				str	,  lowerCamelCase_ :				str	,  lowerCamelCase_ :				str						):
				'''simple docstring'''




				__magic_name__	  = ""
				__magic_name__	  = LETTERS
				__magic_name__	  = key

				if mode == "decrypt":
								__magic_name__  ,      __magic_name__	  = chars_b, chars_a

				for symbol in message:
								if symbol.upper() in chars_a:
												__magic_name__	  = chars_a.find(symbol.upper()						)
												if symbol.isupper():
																translated += chars_b[sym_index].upper()
												else:
																translated += chars_b[sym_index].lower()
								else:
												translated += symbol

				return translated




def      __snake_case       (       ):
				'''simple docstring'''




				__magic_name__	  = list(lowerCamelCase_						)
				random.shuffle(lowerCamelCase_						)
				return "".join(lowerCamelCase_						)


if __name__ == "__main__":
						main()



