
'''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)
_lowercase				:						int												= "\\n"

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

_lowercase				:						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"

_lowercase				:						Dict												= ["fleurs-asr", "mls", "voxpopuli", "babel", "covost2", "fleurs-lang_id", "minds14"]
_lowercase				:						str												= ""

try:
							from jiwer import transforms as tr

							_lowercase				:						str												= True
except ImportError:
							_lowercase				:						Tuple												= False

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






							class 				lowerCAmelCase__     (						tr.AbstractTransform  ):






												def __init__(     self       ,							__SCREAMING_SNAKE_CASE = " "	):


																		"""simple docstring"""





																		lowercase_			:  Optional[Any]									= sentence_delimiter






												def 			_snake_case					(     self       ,							__SCREAMING_SNAKE_CASE	):


																		"""simple docstring"""





																		return list(SCREAMING_SNAKE_CASE_	)






												def 			_snake_case					(     self       ,							__SCREAMING_SNAKE_CASE	):


																		"""simple docstring"""





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







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



						"""simple docstring"""





						return float((preds == labels).mean()							)
def       snake_case_	(       __SCREAMING_SNAKE_CASE      :				Any   ,   __SCREAMING_SNAKE_CASE      :				Optional[int]							):



						"""simple docstring"""





						return {
						    "f1": float(fa_score(y_true=snake_case__   ,   y_pred=snake_case__   ,   average='''macro'''							)							),
						    "accuracy": simple_accuracy(snake_case__   ,   snake_case__							),
						}
def       snake_case_	(       __SCREAMING_SNAKE_CASE      :				Dict   ,   __SCREAMING_SNAKE_CASE      :				Dict   ,   __SCREAMING_SNAKE_CASE      :				List[str]="exp"   ,   __SCREAMING_SNAKE_CASE      :				Optional[int]=None   ,   __SCREAMING_SNAKE_CASE      :				Dict=False   ,   __SCREAMING_SNAKE_CASE      :				List[str]=False   ,   __SCREAMING_SNAKE_CASE      :				Any=None   ,   __SCREAMING_SNAKE_CASE      :				List[Any]=False   ,   ):



						"""simple docstring"""





						lowercase_			:  List[Any]									= [[label] for label in labels]
						lowercase_			:  List[Any]									= list(snake_case__							)
						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"`.'''							)

						lowercase_			:  str									= len(labels[0]							)
						if any(len(snake_case__							) != references_per_prediction for refs in labels							):
												raise ValueError('''Sacrebleu requires the same number of references for each prediction'''							)
						lowercase_			:  Any									= [[refs[i] for refs in labels] for i in range(snake_case__							)]
						lowercase_			:  Tuple									= scb.corpus_bleu(
						    snake_case__   ,   snake_case__   ,   smooth_method=snake_case__   ,   smooth_value=snake_case__   ,   force=snake_case__   ,   lowercase=snake_case__   ,   use_effective_order=snake_case__   ,   **({'''tokenize''': tokenize} if tokenize else {})   ,   )
						return {"bleu": output.score}
def       snake_case_	(       __SCREAMING_SNAKE_CASE      :				Tuple   ,   __SCREAMING_SNAKE_CASE      :				List[str]   ,   __SCREAMING_SNAKE_CASE      :				Optional[int]   ,   __SCREAMING_SNAKE_CASE      :				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:
												lowercase_			:  Dict									= compute_measures(snake_case__   ,   snake_case__							)['wer']

												lowercase_			:  Union[str, Any]									= compute_measures(snake_case__   ,   snake_case__   ,   truth_transform=snake_case__   ,   hypothesis_transform=snake_case__							)['wer']
												return {"wer": wer, "cer": cer}
						else:

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

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






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






					def 			_snake_case					(     self	):


											"""simple docstring"""





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

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






					def 			_snake_case					(     self       ,							__SCREAMING_SNAKE_CASE       ,							__SCREAMING_SNAKE_CASE       ,							__SCREAMING_SNAKE_CASE=None       ,							__SCREAMING_SNAKE_CASE=None	):


											"""simple docstring"""





											lowercase_			:  Optional[Any]									= bleu_kwargs if bleu_kwargs is not None else {}
											lowercase_			:  Dict									= wer_kwargs if wer_kwargs is not None else {}

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





'''simple docstring'''







from itertools import combinations, product
def       snake_case_	(       __SCREAMING_SNAKE_CASE      :				int   ,   __SCREAMING_SNAKE_CASE      :				int   ,   __SCREAMING_SNAKE_CASE      :				int   ,   __SCREAMING_SNAKE_CASE      :				int							):



						"""simple docstring"""





						if xa == ya == 0 or xa == ya == 0:
												return False
						lowercase_			:  Optional[Any]									= xa * xa + ya * ya
						lowercase_			:  List[str]									= xa * xa + ya * ya
						lowercase_			:  Any									= (xa - xa) * (xa - xa) + (ya - ya) * (ya - ya)
						return (
						    a_square + b_square == c_square
						    or a_square + c_square == b_square
						    or b_square + c_square == a_square
						)
def       snake_case_	(       __SCREAMING_SNAKE_CASE      :				int = 50							):



						"""simple docstring"""





						return sum(
						    1
						    for pta, pta in combinations(product(range(limit + 1							)   ,   repeat=2							)   ,   2							)
						    if is_right(*__SCREAMING_SNAKE_CASE   ,   *__SCREAMING_SNAKE_CASE							)							)


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



