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

SCREAMING_SNAKE_CASE__       =	"\\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__       =	"\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__       =	["fleurs-asr", "mls", "voxpopuli", "babel", "covost2", "fleurs-lang_id", "minds14"]
SCREAMING_SNAKE_CASE__       =	""

try:
					from jiwer import transforms as tr

					SCREAMING_SNAKE_CASE__       =	True
except ImportError:
					SCREAMING_SNAKE_CASE__       =	False

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



					class 	lowerCAmelCase_     (      tr.AbstractTransform       ):



									"""simple docstring"""

									def __init__(					self		,     lowerCAmelCase = " "     ):






															"""simple docstring"""

															snake_case             =      sentence_delimiter

									def 		snake_case			(					self		,     lowerCAmelCase     ):






															"""simple docstring"""

															return list(lowerCAmelCase     )

									def 		snake_case			(					self		,     lowerCAmelCase     ):






															"""simple docstring"""

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





					SCREAMING_SNAKE_CASE__       =	tr.Compose(
					    [tr.RemoveMultipleSpaces(), tr.Strip(), SentencesToListOfCharacters(SENTENCE_DELIMITER)]
					)
elif _jiwer_available:
					SCREAMING_SNAKE_CASE__       =	tr.Compose(
					    [
					        tr.RemoveMultipleSpaces(),
					        tr.Strip(),
					        tr.ReduceToSingleSentence(SENTENCE_DELIMITER),
					        tr.ReduceToListOfListOfChars(),
					    ]
					)
else:
					SCREAMING_SNAKE_CASE__       =	None





def  lowerCAmelCase__     (      _UpperCamelCase							:					str			,      _UpperCamelCase							:					str       )       ->					Optional[int]:





						"""simple docstring"""






						return float((preds == labels).mean()       )





def  lowerCAmelCase__     (      _UpperCamelCase							:					str			,      _UpperCamelCase							:					Tuple       )       ->					Union[str, Any]:





						"""simple docstring"""






						return {
						    "f1": float(fa_score(y_true=_UpperCamelCase			,      y_pred=_UpperCamelCase			,      average='macro'       )       ),
						    "accuracy": simple_accuracy(_UpperCamelCase			,      _UpperCamelCase       ),
						}





def  lowerCAmelCase__     (      _UpperCamelCase							:					Optional[int]			,      _UpperCamelCase							:					Any			,      _UpperCamelCase							:					List[Any]="exp"			,      _UpperCamelCase							:					int=None			,      _UpperCamelCase							:					List[Any]=False			,      _UpperCamelCase							:					Optional[int]=False			,      _UpperCamelCase							:					Optional[Any]=None			,      _UpperCamelCase							:					Any=False			,      )       ->					Optional[int]:





						"""simple docstring"""






						snake_case             =      [[label] for label in labels]
						snake_case             =      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"`.'       )

						snake_case             =      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'       )
						snake_case             =      [[refs[i] for refs in labels] for i in range(_UpperCamelCase       )]
						snake_case             =      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__     (      _UpperCamelCase							:					Optional[Any]			,      _UpperCamelCase							:					Dict			,      _UpperCamelCase							:					List[Any]			,      _UpperCamelCase							:					List[Any]       )       ->					Optional[int]:





						"""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:
												snake_case             =      compute_measures(_UpperCamelCase			,      _UpperCamelCase       )['wer']

												snake_case             =      compute_measures(_UpperCamelCase			,      _UpperCamelCase			,      truth_transform=_UpperCamelCase			,      hypothesis_transform=_UpperCamelCase       )['wer']
												return {"wer": wer, "cer": cer}
						else:

												def compute_score(_UpperCamelCase							:					List[str]			,      _UpperCamelCase							:					Tuple			,      _UpperCamelCase							:					Optional[int]="wer"       ):
																		snake_case             =      0
																		snake_case             =      0
																		for prediction, reference in zip(_UpperCamelCase			,      _UpperCamelCase       ):
																								if score_type == "wer":
																														snake_case             =      compute_measures(_UpperCamelCase			,      _UpperCamelCase       )
																								elif score_type == "cer":
																														snake_case             =      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 	lowerCAmelCase_     (      datasets.Metric       ):



				"""simple docstring"""

				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}"""     )

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

				def 		snake_case			(					self		,     lowerCAmelCase		,     lowerCAmelCase		,     lowerCAmelCase=None		,     lowerCAmelCase=None     ):






										"""simple docstring"""

										snake_case             =      bleu_kwargs if bleu_kwargs is not None else {}
										snake_case             =      wer_kwargs if wer_kwargs is not None else {}

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



"""simple docstring"""
from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_sentencepiece_available,
    is_tokenizers_available,
    is_torch_available,
)


SCREAMING_SNAKE_CASE__       =	{
    "configuration_open_llama": ["OPEN_LLAMA_PRETRAINED_CONFIG_ARCHIVE_MAP", "OpenLlamaConfig"],
}

try:
					if not is_sentencepiece_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					SCREAMING_SNAKE_CASE__       =	["LlamaTokenizer"]

try:
					if not is_tokenizers_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					SCREAMING_SNAKE_CASE__       =	["LlamaTokenizerFast"]

try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					SCREAMING_SNAKE_CASE__       =	[
					    "OpenLlamaForCausalLM",
					    "OpenLlamaModel",
					    "OpenLlamaPreTrainedModel",
					    "OpenLlamaForSequenceClassification",
					]


if TYPE_CHECKING:
					from .configuration_open_llama import OPEN_LLAMA_PRETRAINED_CONFIG_ARCHIVE_MAP, OpenLlamaConfig

					try:
										if not is_sentencepiece_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from transformers import LlamaTokenizer

					try:
										if not is_tokenizers_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from transformers import LlamaTokenizerFast

					try:
										if not is_torch_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_open_llama import (
										    OpenLlamaForCausalLM,
										    OpenLlamaForSequenceClassification,
										    OpenLlamaModel,
										    OpenLlamaPreTrainedModel,
										)


else:
					import sys

					SCREAMING_SNAKE_CASE__       =	_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)


