


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

__magic_name__	:   Any          =							'\\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__	:   Optional[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__	:   Tuple          =							['fleurs-asr', 'mls', 'voxpopuli', 'babel', 'covost2', 'fleurs-lang_id', 'minds14']
__magic_name__	:   Dict          =							''

try:
					from jiwer import transforms as tr

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

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




					class  __snake_case      (tr.AbstractTransform     ):




												def __init__(    self:						Union[str, Any]    ,       A_:						str = " "      ):
															__lowerCamelCase        =			sentence_delimiter




												def      __a      (    self:						Any    ,       A_:						str      ):
															return list(A_      )




												def      __a      (    self:						Union[str, Any]    ,       A_:						List[str]      ):
															__lowerCamelCase        =			[]
															for sent_idx, sentence in enumerate(A_      ):
																		chars.extend(self.process_string(A_      )      )
																		if self.sentence_delimiter is not None and self.sentence_delimiter != "" and sent_idx < len(A_      ) - 1:
																					chars.append(self.sentence_delimiter      )
															return chars

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





def 			a_   (  lowercase__   :str, lowercase__   :Union[str, Any]    ):
			return float((preds == labels).mean()    )





def 			a_   (  lowercase__   :Dict, lowercase__   :List[str]    ):
			return {
			    "f1": float(fa_score(y_true=lowercase__, y_pred=lowercase__, average="""macro"""    )    ),
			    "accuracy": simple_accuracy(lowercase__, lowercase__    ),
			}





def 			a_   (  lowercase__   :str, lowercase__   :Optional[Any], lowercase__   :List[str]="exp", lowercase__   :Dict=None, lowercase__   :List[Any]=False, lowercase__   :List[Any]=False, lowercase__   :List[str]=None, lowercase__   :Any=False, ):
			# xtreme-s can only have one label
			__lowerCamelCase        =			[[label] for label in labels]
			__lowerCamelCase        =			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\"`."""    )

			__lowerCamelCase        =			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"""    )
			__lowerCamelCase        =			[[refs[i] for refs in labels] for i in range(lowercase__    )]
			__lowerCamelCase        =			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 			a_   (  lowercase__   :Union[str, Any], lowercase__   :Union[str, Any], lowercase__   :Optional[int], lowercase__   :Tuple    ):
			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(lowercase__, lowercase__    )["""wer"""]

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

						def compute_score(lowercase__   :Optional[Any], lowercase__   :List[Any], lowercase__   :Dict="wer"    ):
									__lowerCamelCase        =			0
									__lowerCamelCase        =			0
									for prediction, reference in zip(lowercase__, lowercase__    ):
												if score_type == "wer":
															__lowerCamelCase        =			compute_measures(lowercase__, lowercase__    )
												elif score_type == "cer":
															__lowerCamelCase        =			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  __snake_case      (datasets.Metric     ):




							def      __a      (    self:						Union[str, Any]      ):
										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(A_      ), """references""": datasets.Value(A_      )}      )    ,       codebase_urls=[]    ,       reference_urls=[]    ,       format="""numpy"""    ,       )




							def      __a      (    self:						List[Any]    ,       A_:						Any    ,       A_:						Any    ,       A_:						Tuple=None    ,       A_:						Optional[int]=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(A_    ,       A_      )}
										elif self.config_name == "minds14":
													return fa_and_simple_accuracy(A_    ,       A_      )
										elif self.config_name == "covost2":
													__lowerCamelCase        =			bleu_kwargs.pop("""smooth_method"""    ,       """exp"""      )
													__lowerCamelCase        =			bleu_kwargs.pop("""smooth_value"""    ,       A_      )
													__lowerCamelCase        =			bleu_kwargs.pop("""force"""    ,       A_      )
													__lowerCamelCase        =			bleu_kwargs.pop("""lowercase"""    ,       A_      )
													__lowerCamelCase        =			bleu_kwargs.pop("""tokenize"""    ,       A_      )
													__lowerCamelCase        =			bleu_kwargs.pop("""use_effective_order"""    ,       A_      )
													return bleu(
													    preds=A_    ,       labels=A_    ,       smooth_method=A_    ,       smooth_value=A_    ,       force=A_    ,       lowercase=A_    ,       tokenize=A_    ,       use_effective_order=A_    ,       )
										elif self.config_name in ["fleurs-asr", "mls", "voxpopuli", "babel"]:
													__lowerCamelCase        =			wer_kwargs.pop("""concatenate_texts"""    ,       A_      )
													return wer_and_cer(A_    ,       A_    ,       A_    ,       self.config_name      )
										else:
													raise KeyError(f'You should supply a configuration name selected in {_CONFIG_NAMES}'      )








"""simple docstring"""




import os





def 			a_   (  ):
			__lowerCamelCase        =			os.path.dirname(os.path.realpath(lowercase__    )    )
			__lowerCamelCase        =			os.path.join(lowercase__, """triangle.txt"""    )

			with open(lowercase__    ) as in_file:
						__lowerCamelCase        =			[[int(lowercase__    ) for i in line.split()] for line in in_file]

			while len(lowercase__    ) != 1:
						__lowerCamelCase        =			triangle.pop()
						__lowerCamelCase        =			triangle[-1]
						for j in range(len(lowercase__    ) - 1    ):
									curr_row[j] += max(last_row[j], last_row[j + 1]    )
			return triangle[0][0]


if __name__ == "__main__":
					print(solution())




