





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)
UpperCAmelCase__  :	List[Any]     ='''\
'''

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

UpperCAmelCase__  :	Optional[int]     ='''
Compute XTREME-S evaluation metric associated to each XTREME-S dataset.
Args:
    predictions: list of predictions to score.
        Each translation should be tokenized into a list of tokens.
    references: list of lists of references for each translation.
        Each reference should be tokenized into a list of tokens.
    bleu_kwargs: optional dict of keywords to be passed when computing \'bleu\'.
        Keywords include Dict can be one of \'smooth_method\', \'smooth_value\', \'force\', \'lowercase\',
        \'tokenize\', \'use_effective_order\'.
    wer_kwargs: optional dict of keywords to be passed when computing \'wer\' and \'cer\'.
        Keywords include \'concatenate_texts\'.
Returns: depending on the XTREME-S task, one or several of:
    "accuracy": Accuracy - for \'fleurs-lang_id\', \'minds14\'
    "f1": F1 score - for \'minds14\'
    "wer": Word error rate - for \'mls\', \'fleurs-asr\', \'voxpopuli\', \'babel\'
    "cer": Character error rate - for \'mls\', \'fleurs-asr\', \'voxpopuli\', \'babel\'
    "bleu": BLEU score according to the `sacrebleu` metric - for \'covost2\'
Examples:

    >>> xtreme_s_metric = datasets.load_metric(\'xtreme_s\', \'mls\')  # \'mls\', \'voxpopuli\', \'fleurs-asr\' or \'babel\'
    >>> references = ["it is sunny here", "paper and pen are essentials"]
    >>> predictions = ["it\'s sunny", "paper pen are essential"]
    >>> results = xtreme_s_metric.compute(predictions=predictions, references=references)
    >>> print({k: round(v, 2) for k, v in results.items()})
    {\'wer\': 0.56, \'cer\': 0.27}

    >>> xtreme_s_metric = datasets.load_metric(\'xtreme_s\', \'covost2\')
    >>> references = ["bonjour paris", "il est necessaire de faire du sport de temps en temp"]
    >>> predictions = ["bonjour paris", "il est important de faire du sport souvent"]
    >>> results = xtreme_s_metric.compute(predictions=predictions, references=references)
    >>> print({k: round(v, 2) for k, v in results.items()})
    {\'bleu\': 31.65}

    >>> xtreme_s_metric = datasets.load_metric(\'xtreme_s\', \'fleurs-lang_id\')
    >>> references = [0, 1, 0, 0, 1]
    >>> predictions = [0, 1, 1, 0, 0]
    >>> results = xtreme_s_metric.compute(predictions=predictions, references=references)
    >>> print({k: round(v, 2) for k, v in results.items()})
    {\'accuracy\': 0.6}

    >>> xtreme_s_metric = datasets.load_metric(\'xtreme_s\', \'minds14\')
    >>> references = [0, 1, 0, 0, 1]
    >>> predictions = [0, 1, 1, 0, 0]
    >>> results = xtreme_s_metric.compute(predictions=predictions, references=references)
    >>> print({k: round(v, 2) for k, v in results.items()})
    {\'f1\': 0.58, \'accuracy\': 0.6}
'''

UpperCAmelCase__  :	Optional[int]     =['''fleurs-asr''', '''mls''', '''voxpopuli''', '''babel''', '''covost2''', '''fleurs-lang_id''', '''minds14''']
UpperCAmelCase__  :	Tuple     =''''''

try:
							from jiwer import transforms as tr

							UpperCAmelCase__  :	Union[str, Any]     =True
except ImportError:
							UpperCAmelCase__  :	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      ,       UpperCAmelCase_ = " "							):
															lowerCamelCase		       =sentence_delimiter


											def _snake_case				(						self      ,       UpperCAmelCase_							):
															return list(UpperCAmelCase_							)


											def _snake_case				(						self      ,       UpperCAmelCase_							):
															lowerCamelCase		       =[]
															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




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





def    _lowercase    (  _UpperCAmelCase	,					_UpperCAmelCase )  ->     List[Any]:
				return float((preds == labels).mean() )





def    _lowercase    (  _UpperCAmelCase	,					_UpperCAmelCase )  ->     int:
				return {
				    "f1": float(fa_score(y_true=_UpperCAmelCase	,					y_pred=_UpperCAmelCase	,					average="""macro""" ) ),
				    "accuracy": simple_accuracy(_UpperCAmelCase	,					_UpperCAmelCase ),
				}





def    _lowercase    (  _UpperCAmelCase	,					_UpperCAmelCase	,					_UpperCAmelCase="exp"	,					_UpperCAmelCase=None	,					_UpperCAmelCase=False	,					_UpperCAmelCase=False	,					_UpperCAmelCase=None	,					_UpperCAmelCase=False	,					)  ->     Tuple:
				# xtreme-s can only have one label
				lowerCamelCase		       =[[label] for label in labels]
				lowerCamelCase		       =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\"`.""" )

				lowerCamelCase		       =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""" )
				lowerCamelCase		       =[[refs[i] for refs in labels] for i in range(_UpperCAmelCase )]
				lowerCamelCase		       =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    _lowercase    (  _UpperCAmelCase	,					_UpperCAmelCase	,					_UpperCAmelCase	,					_UpperCAmelCase )  ->     Union[str, 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:
								lowerCamelCase		       =compute_measures(_UpperCAmelCase	,					_UpperCAmelCase )["""wer"""]

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

								def compute_score(_UpperCAmelCase	,					_UpperCAmelCase	,					_UpperCAmelCase="wer" ):
												lowerCamelCase		       =0
												lowerCamelCase		       =0
												for prediction, reference in zip(_UpperCAmelCase	,					_UpperCAmelCase ):
																if score_type == "wer":
																				lowerCamelCase		       =compute_measures(_UpperCAmelCase	,					_UpperCAmelCase )
																elif score_type == "cer":
																				lowerCamelCase		       =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 _snake_case				(						self							):
								if self.config_name not in _CONFIG_NAMES:
												raise KeyError(f"""You should supply a configuration name selected in {_CONFIG_NAMES}"""							)

								lowerCamelCase		       ="""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 _snake_case				(						self      ,       UpperCAmelCase_      ,       UpperCAmelCase_      ,       UpperCAmelCase_=None      ,       UpperCAmelCase_=None							):
								lowerCamelCase		       =bleu_kwargs if bleu_kwargs is not None else {}
								lowerCamelCase		       =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":
												lowerCamelCase		       =bleu_kwargs.pop("""smooth_method"""      ,       """exp"""							)
												lowerCamelCase		       =bleu_kwargs.pop("""smooth_value"""      ,       UpperCAmelCase_							)
												lowerCamelCase		       =bleu_kwargs.pop("""force"""      ,       UpperCAmelCase_							)
												lowerCamelCase		       =bleu_kwargs.pop("""lowercase"""      ,       UpperCAmelCase_							)
												lowerCamelCase		       =bleu_kwargs.pop("""tokenize"""      ,       UpperCAmelCase_							)
												lowerCamelCase		       =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"]:
												lowerCamelCase		       =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}"""							)












def    _lowercase    (  _UpperCAmelCase = 99_80_01 )  ->     int:

				# fetches the next number
				for number in range(n - 1	,					99_99	,					-1 ):
								lowerCamelCase		       =str(_UpperCAmelCase )

								# checks whether 'str_number' is a palindrome.
								if str_number == str_number[::-1]:
												lowerCamelCase		       =9_99

												# if 'number' is a product of two 3-digit numbers
												# then number is the answer otherwise fetch next number.
												while divisor != 99:
																if (number % divisor == 0) and (len(str(number // divisor ) ) == 3.0):
																				return number
																divisor -= 1
				raise ValueError("""That number is larger than our acceptable range.""" )


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





