
'''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)
__SCREAMING_SNAKE_CASE		:  Optional[int]        =      '\\n'

__SCREAMING_SNAKE_CASE		:  Tuple        =      '\\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'

__SCREAMING_SNAKE_CASE		:  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'

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

try:
					from jiwer import transforms as tr

					__SCREAMING_SNAKE_CASE		:  Optional[Any]        =      True
except ImportError:
					__SCREAMING_SNAKE_CASE		:  Dict        =      False

if _jiwer_available and version.parse(importlib_metadata.version('jiwer')) < version.parse('2.3.0'):
					class  SCREAMING_SNAKE_CASE__       (  tr.AbstractTransform   ):
						def __init__(				self  ,    __UpperCamelCase = " "			):



										'''simple docstring'''






										__a       :     Union[str, Any]								=	sentence_delimiter
						def __lowerCamelCase    (				self  ,    __UpperCamelCase			):



										'''simple docstring'''






										return list(__UpperCamelCase			)

						def __lowerCamelCase    (				self  ,    __UpperCamelCase			):



										'''simple docstring'''






										__a       :     Tuple								=	[]
										for sent_idx, sentence in enumerate(__UpperCamelCase			):
														chars.extend(self.process_string(__UpperCamelCase			)			)
														if self.sentence_delimiter is not None and self.sentence_delimiter != "" and sent_idx < len(__UpperCamelCase			) - 1:
																		chars.append(self.sentence_delimiter			)
										return chars







					__SCREAMING_SNAKE_CASE		:  Union[str, Any]        =      tr.Compose(
					    [tr.RemoveMultipleSpaces(), tr.Strip(), SentencesToListOfCharacters(SENTENCE_DELIMITER)]
					)
elif _jiwer_available:
					__SCREAMING_SNAKE_CASE		:  List[str]        =      tr.Compose(
					    [
					        tr.RemoveMultipleSpaces(),
					        tr.Strip(),
					        tr.ReduceToSingleSentence(SENTENCE_DELIMITER),
					        tr.ReduceToListOfListOfChars(),
					    ]
					)
else:
					__SCREAMING_SNAKE_CASE		:  int        =      None

def 				_snake_case (		lowercase			,    lowercase						)       ->       str:
				return float((preds == labels).mean()						)

def 				_snake_case (		lowercase			,    lowercase						)       ->       List[str]:
				return {
				    "f1": float(fa_score(y_true=lowercase			,    y_pred=lowercase			,    average="""macro"""						)						),
				    "accuracy": simple_accuracy(lowercase			,    lowercase						),
				}

def 				_snake_case (		lowercase			,    lowercase			,    lowercase="exp"			,    lowercase=None			,    lowercase=False			,    lowercase=False			,    lowercase=None			,    lowercase=False			,    )       ->       int:
				# xtreme-s can only have one label
				__a       :     Optional[int]								=	[[label] for label in labels]
				__a       :     Any								=	list(lowercase						)
				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\"`."""						)

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

def 				_snake_case (		lowercase			,    lowercase			,    lowercase			,    lowercase						)       ->       Any:
				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:
								__a       :     str								=	compute_measures(lowercase			,    lowercase						)["""wer"""]

								__a       :     str								=	compute_measures(lowercase			,    lowercase			,    truth_transform=lowercase			,    hypothesis_transform=lowercase						)["""wer"""]
								return {"wer": wer, "cer": cer}
				else:

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

								return {"wer": compute_score(lowercase			,    lowercase			,    """wer"""						), "cer": compute_score(lowercase			,    lowercase			,    """cer"""						)}
@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION			,					_KWARGS_DESCRIPTION   )
class  SCREAMING_SNAKE_CASE__       (  datasets.Metric   ):
	def __lowerCamelCase    (				self			):



					'''simple docstring'''






					if self.config_name not in _CONFIG_NAMES:
									raise KeyError(f"""You should supply a configuration name selected in {_CONFIG_NAMES}"""			)

					__a       :     List[Any]								=	"""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(__UpperCamelCase			), """references""": datasets.Value(__UpperCamelCase			)}			)  ,    codebase_urls=[]  ,    reference_urls=[]  ,    format="""numpy"""  ,    )

	def __lowerCamelCase    (				self  ,    __UpperCamelCase  ,    __UpperCamelCase  ,    __UpperCamelCase=None  ,    __UpperCamelCase=None			):



					'''simple docstring'''






					__a       :     List[Any]								=	bleu_kwargs if bleu_kwargs is not None else {}
					__a       :     int								=	wer_kwargs if wer_kwargs is not None else {}

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

'''simple docstring'''







def 				_snake_case (		lowercase						)       ->       int:
				if not isinstance(lowercase			,    lowercase						):
								__a       :     Union[str, Any]								=	F"""Input value of [number={number}] must be an integer"""
								raise TypeError(lowercase						)
				if number < 1:
								raise ValueError("""Input must be a positive integer"""						)
				return number * (2 * number - 1)


if __name__ == "__main__":
					import doctest

					doctest.testmod()