





'''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)
snake_case_  :							Tuple            =	"\\n"

snake_case_  :							List[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"

snake_case_  :							int            =	"\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"

snake_case_  :							List[Any]            =	["fleurs-asr", "mls", "voxpopuli", "babel", "covost2", "fleurs-lang_id", "minds14"]
snake_case_  :							Optional[int]            =	""

try:
					from jiwer import transforms as tr

					snake_case_  :							Union[str, Any]            =	True
except ImportError:
					snake_case_  :							Union[str, Any]            =	False

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


					class        __a   (tr.AbstractTransform  ):

												def __init__(				self				:  List[str]							,  __magic_name__				:  str = " " )       ->							Any:







																		"""simple docstring"""
																		UpperCAmelCase_      :   Optional[int]      =	sentence_delimiter

												def      UpperCAmelCase__						(				self				:  List[str]							,  __magic_name__				:  str )       ->							Tuple:







																		"""simple docstring"""
																		return list(__magic_name__ )



												def      UpperCAmelCase__						(				self				:  Optional[Any]							,  __magic_name__				:  List[str] )       ->							Optional[Any]:







																		"""simple docstring"""
																		UpperCAmelCase_      :   List[str]      =	[]
																		for sent_idx, sentence in enumerate(__magic_name__ ):
																								chars.extend(self.process_string(__magic_name__ ) )
																								if self.sentence_delimiter is not None and self.sentence_delimiter != "" and sent_idx < len(__magic_name__ ) - 1:
																														chars.append(self.sentence_delimiter )
																		return chars





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





def 							lowerCamelCase_   (	SCREAMING_SNAKE_CASE__   :      Optional[int],      SCREAMING_SNAKE_CASE__   :      Union[str, Any] )			->						Optional[Any]:
						return float((preds == labels).mean() )





def 							lowerCamelCase_   (	SCREAMING_SNAKE_CASE__   :      List[str],      SCREAMING_SNAKE_CASE__   :      List[str] )			->						Union[str, Any]:
						return {
						    "f1": float(fa_score(y_true=UpperCAmelCase__,      y_pred=UpperCAmelCase__,      average='''macro''' ) ),
						    "accuracy": simple_accuracy(UpperCAmelCase__,      UpperCAmelCase__ ),
						}





def 							lowerCamelCase_   (	SCREAMING_SNAKE_CASE__   :      str,      SCREAMING_SNAKE_CASE__   :      Optional[int],      SCREAMING_SNAKE_CASE__   :      Tuple="exp",      SCREAMING_SNAKE_CASE__   :      Optional[int]=None,      SCREAMING_SNAKE_CASE__   :      List[str]=False,      SCREAMING_SNAKE_CASE__   :      Tuple=False,      SCREAMING_SNAKE_CASE__   :      List[str]=None,      SCREAMING_SNAKE_CASE__   :      List[Any]=False,      )			->						Optional[int]:
						# xtreme-s can only have one label
						UpperCAmelCase_      :   List[Any]      =	[[label] for label in labels]
						UpperCAmelCase_      :   Any      =	list(UpperCAmelCase__ )
						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\"`.''' )

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





def 							lowerCamelCase_   (	SCREAMING_SNAKE_CASE__   :      Dict,      SCREAMING_SNAKE_CASE__   :      Optional[Any],      SCREAMING_SNAKE_CASE__   :      Optional[Any],      SCREAMING_SNAKE_CASE__   :      Any )			->						List[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:
												UpperCAmelCase_      :   int      =	compute_measures(UpperCAmelCase__,      UpperCAmelCase__ )["""wer"""]

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

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

												return {"wer": compute_score(UpperCAmelCase__,      UpperCAmelCase__,      '''wer''' ), "cer": compute_score(UpperCAmelCase__,      UpperCAmelCase__,      '''cer''' )}


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

							def      UpperCAmelCase__						(				self				:  Dict )       ->							Any:







													"""simple docstring"""





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

													UpperCAmelCase_      :   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(__magic_name__ ), '''references''': datasets.Value(__magic_name__ )} )							,  codebase_urls=[]							,  reference_urls=[]							,  format='''numpy'''							,  )



							def      UpperCAmelCase__						(				self				:  List[Any]							,  __magic_name__				:  Any							,  __magic_name__				:  Dict							,  __magic_name__				:  Optional[Any]=None							,  __magic_name__				:  int=None )       ->							Dict:







													"""simple docstring"""
													UpperCAmelCase_      :   int      =	bleu_kwargs if bleu_kwargs is not None else {}
													UpperCAmelCase_      :   Optional[Any]      =	wer_kwargs if wer_kwargs is not None else {}

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













"""simple docstring"""



def   _lowerCAmelCase		(				UpperCAmelCase__							:       int = 4_0_0_0_0_0_0   )		->int:
						A__    :	int			=	1
						A__    :	List[str]			=	2
						A__    :	Union[str, Any]			=	0
						while j <= n:
												if j % 2 == 0:
																		total += j
												A__	,	A__    :	str			=	j, i + j

						return total


if __name__ == "__main__":
						print(F'{solution() = }')






