





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:  List[Any]   =   """\
    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:  Any   =   """
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[Any]   =   ["""fleurs-asr""", """mls""", """voxpopuli""", """babel""", """covost2""", """fleurs-lang_id""", """minds14"""]
__UpperCamelCase:  Union[str, Any]   =   """"""

try:
			from jiwer import transforms as tr

			__UpperCamelCase:  Any   =   True
except ImportError:
			__UpperCamelCase:  str   =   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:	List[Any],				lowerCamelCase_:	str = " " ):
						lowercase__				:			int            =		sentence_delimiter

				def       snake_case__(	self:	str,				lowerCamelCase_:	str ):
						return list(lowerCamelCase_ )





				def       snake_case__(	self:	Optional[Any],				lowerCamelCase_:	List[str] ):
						lowercase__				:			int            =		[]
						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
			__UpperCamelCase:  int   =   tr.Compose(
			    [tr.RemoveMultipleSpaces(), tr.Strip(), SentencesToListOfCharacters(SENTENCE_DELIMITER)]
			)
elif _jiwer_available:
			__UpperCamelCase:  str   =   tr.Compose(
			    [
			        tr.RemoveMultipleSpaces(),
			        tr.Strip(),
			        tr.ReduceToSingleSentence(SENTENCE_DELIMITER),
			        tr.ReduceToListOfListOfChars(),
			    ]
			)
else:
			__UpperCamelCase:  str   =   None


def 			SCREAMING_SNAKE_CASE__     (					_lowercase    :   str      ,						_lowercase    :   List[str] )      ->       Dict:




		'''simple docstring'''
		return float((preds == labels).mean() )


def 			SCREAMING_SNAKE_CASE__     (					_lowercase    :   int      ,						_lowercase    :   int )      ->       Tuple:




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


def 			SCREAMING_SNAKE_CASE__     (					_lowercase    :   Any      ,						_lowercase    :   List[Any]      ,						_lowercase    :   Dict="exp"      ,						_lowercase    :   List[Any]=None      ,						_lowercase    :   Any=False      ,						_lowercase    :   List[str]=False      ,						_lowercase    :   Dict=None      ,						_lowercase    :   int=False      ,						)      ->       str:




		'''simple docstring'''
		# xtreme-s can only have one label
		lowercase__				:			Dict            =		[[label] for label in labels]
		lowercase__				:			str            =		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"`.' )

		lowercase__				:			List[Any]            =		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' )
		lowercase__				:			List[Any]            =		[[refs[i] for refs in labels] for i in range(_lowercase )]
		lowercase__				:			str            =		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 			SCREAMING_SNAKE_CASE__     (					_lowercase    :   int      ,						_lowercase    :   int      ,						_lowercase    :   Optional[Any]      ,						_lowercase    :   str )      ->       Optional[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__				:			Union[str, Any]            =		compute_measures(_lowercase      ,						_lowercase )['wer']

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

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


	'''simple docstring'''





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

			lowercase__				:			Dict            =		'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:	Dict,				lowerCamelCase_:	str,				lowerCamelCase_:	int,				lowerCamelCase_:	int=None,				lowerCamelCase_:	Union[str, Any]=None ):
			lowercase__				:			int            =		bleu_kwargs if bleu_kwargs is not None else {}
			lowercase__				:			Any            =		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":
					lowercase__				:			Any            =		bleu_kwargs.pop('smooth_method',				'exp' )
					lowercase__				:			Dict            =		bleu_kwargs.pop('smooth_value',				lowerCamelCase_ )
					lowercase__				:			int            =		bleu_kwargs.pop('force',				lowerCamelCase_ )
					lowercase__				:			Union[str, Any]            =		bleu_kwargs.pop('lowercase',				lowerCamelCase_ )
					lowercase__				:			Optional[int]            =		bleu_kwargs.pop('tokenize',				lowerCamelCase_ )
					lowercase__				:			Optional[Any]            =		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"]:
					lowercase__				:			Dict            =		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}""" )









from typing import TYPE_CHECKING

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


__UpperCamelCase:  Dict   =   {
    """configuration_deberta_v2""": ["""DEBERTA_V2_PRETRAINED_CONFIG_ARCHIVE_MAP""", """DebertaV2Config""", """DebertaV2OnnxConfig"""],
    """tokenization_deberta_v2""": ["""DebertaV2Tokenizer"""],
}

try:
			if not is_tokenizers_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			__UpperCamelCase:  List[Any]   =   ["""DebertaV2TokenizerFast"""]

try:
			if not is_tf_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			__UpperCamelCase:  str   =   [
			    """TF_DEBERTA_V2_PRETRAINED_MODEL_ARCHIVE_LIST""",
			    """TFDebertaV2ForMaskedLM""",
			    """TFDebertaV2ForQuestionAnswering""",
			    """TFDebertaV2ForSequenceClassification""",
			    """TFDebertaV2ForTokenClassification""",
			    """TFDebertaV2Model""",
			    """TFDebertaV2PreTrainedModel""",
			]

try:
			if not is_torch_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			__UpperCamelCase:  Tuple   =   [
			    """DEBERTA_V2_PRETRAINED_MODEL_ARCHIVE_LIST""",
			    """DebertaV2ForMaskedLM""",
			    """DebertaV2ForMultipleChoice""",
			    """DebertaV2ForQuestionAnswering""",
			    """DebertaV2ForSequenceClassification""",
			    """DebertaV2ForTokenClassification""",
			    """DebertaV2Model""",
			    """DebertaV2PreTrainedModel""",
			]


if TYPE_CHECKING:
			from .configuration_deberta_va import (
			    DEBERTA_V2_PRETRAINED_CONFIG_ARCHIVE_MAP,
			    DebertaVaConfig,
			    DebertaVaOnnxConfig,
			)
			from .tokenization_deberta_va import DebertaVaTokenizer

			try:
						if not is_tokenizers_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .tokenization_deberta_va_fast import DebertaVaTokenizerFast

			try:
						if not is_tf_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .modeling_tf_deberta_va import (
						    TF_DEBERTA_V2_PRETRAINED_MODEL_ARCHIVE_LIST,
						    TFDebertaVaForMaskedLM,
						    TFDebertaVaForQuestionAnswering,
						    TFDebertaVaForSequenceClassification,
						    TFDebertaVaForTokenClassification,
						    TFDebertaVaModel,
						    TFDebertaVaPreTrainedModel,
						)

			try:
						if not is_torch_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .modeling_deberta_va import (
						    DEBERTA_V2_PRETRAINED_MODEL_ARCHIVE_LIST,
						    DebertaVaForMaskedLM,
						    DebertaVaForMultipleChoice,
						    DebertaVaForQuestionAnswering,
						    DebertaVaForSequenceClassification,
						    DebertaVaForTokenClassification,
						    DebertaVaModel,
						    DebertaVaPreTrainedModel,
						)

else:
			import sys

			__UpperCamelCase:  Optional[Any]   =   _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)


