



import warnings

from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding


class   lowerCamelCase__  (					_A):



 """simple docstring"""

 a__				:   Any   =     ["image_processor", "tokenizer"]
 a__				:   str   =     "VideoMAEImageProcessor"
 a__				:   int   =     ("CLIPTokenizer", "CLIPTokenizerFast")

 def __init__(						self				:				List[Any] ,	__lowerCAmelCase				:				List[str]=None ,	__lowerCAmelCase				:				Any=None ,	**__lowerCAmelCase				:				int			)      ->  Optional[Any]:
    _A						     =					None
    if "feature_extractor" in kwargs:
       warnings.warn(
           '''The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`'''
           ''' instead.''' ,	__lowerCAmelCase ,	)
       _A						     =					kwargs.pop('''feature_extractor'''			)

    _A						     =					image_processor if image_processor is not None else feature_extractor
    if image_processor is None:
       raise ValueError('''You need to specify an `image_processor`.'''			)
    if tokenizer is None:
       raise ValueError('''You need to specify a `tokenizer`.'''			)

    super().__init__(__lowerCAmelCase ,	__lowerCAmelCase			)
    _A						     =					self.image_processor

 def __call__(						self				:				List[Any] ,	__lowerCAmelCase				:				Union[str, Any]=None ,	__lowerCAmelCase				:				List[str]=None ,	__lowerCAmelCase				:				int=None ,	**__lowerCAmelCase				:				List[str]			)      ->  Union[str, Any]:

    if text is None and videos is None:
       raise ValueError('''You have to specify either text or videos. Both cannot be none.'''			)

    if text is not None:
       _A						     =					self.tokenizer(__lowerCAmelCase ,	return_tensors=__lowerCAmelCase ,	**__lowerCAmelCase			)

    if videos is not None:
       _A						     =					self.image_processor(__lowerCAmelCase ,	return_tensors=__lowerCAmelCase ,	**__lowerCAmelCase			)

    if text is not None and videos is not None:
       _A						     =					image_features.pixel_values
       return encoding
    elif text is not None:
       return encoding
    else:
       return BatchEncoding(data=dict(**__lowerCAmelCase			) ,	tensor_type=__lowerCAmelCase			)

 def 						snake_case_			(						self				:				List[Any] ,	*__lowerCAmelCase				:				Optional[Any] ,	**__lowerCAmelCase				:				List[str]			)      ->  List[Any]:
    return self.tokenizer.batch_decode(*__lowerCAmelCase ,	**__lowerCAmelCase			)

 def 						snake_case_			(						self				:				List[Any] ,	*__lowerCAmelCase				:				List[Any] ,	**__lowerCAmelCase				:				Dict			)      ->  Optional[int]:
    return self.tokenizer.decode(*__lowerCAmelCase ,	**__lowerCAmelCase			)

 @property
 def 						snake_case_			(						self				:				Optional[Any]			)      ->  List[str]:
    return ["input_ids", "attention_mask", "position_ids", "pixel_values"]

 @property
 def 						snake_case_			(						self				:				Tuple			)      ->  Optional[int]:
    warnings.warn(
        '''`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead.''' ,	__lowerCAmelCase ,	)
    return self.image_processor_class

 @property
 def 						snake_case_			(						self				:				Dict			)      ->  Optional[Any]:
    warnings.warn(
        '''`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead.''' ,	__lowerCAmelCase ,	)
    return self.image_processor








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_		   =				"""\
"""

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

try:
   from jiwer import transforms as tr

   UpperCAmelCase_		   =				True
except ImportError:
   UpperCAmelCase_		   =				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				:				str ,	__lowerCAmelCase				:				str = " "			)      ->  Any:
       _A						     =					sentence_delimiter

    def 						snake_case_			(						self				:				List[str] ,	__lowerCAmelCase				:				str			)      ->  Optional[int]:
       return list(__lowerCAmelCase			)

    def 						snake_case_			(						self				:				Union[str, Any] ,	__lowerCAmelCase				:				List[str]			)      ->  Optional[Any]:
       _A						     =					[]
       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_		   =				tr.Compose(
       [tr.RemoveMultipleSpaces(), tr.Strip(), SentencesToListOfCharacters(SENTENCE_DELIMITER)]
   )
elif _jiwer_available:
   UpperCAmelCase_		   =				tr.Compose(
       [
           tr.RemoveMultipleSpaces(),
           tr.Strip(),
           tr.ReduceToSingleSentence(SENTENCE_DELIMITER),
           tr.ReduceToListOfListOfChars(),
       ]
   )
else:
   UpperCAmelCase_		   =				None

def   SCREAMING_SNAKE_CASE_       (  _snake_case  :Dict  ,      _snake_case  :Union[str, Any]							)     ->    int:
   return float((preds == labels).mean()							)

def   SCREAMING_SNAKE_CASE_       (  _snake_case  :int  ,      _snake_case  :Dict							)     ->    Optional[Any]:
   return {
       "f1": float(fa_score(y_true=_snake_case  ,      y_pred=_snake_case  ,      average='''macro'''							)							),
       "accuracy": simple_accuracy(_snake_case  ,      _snake_case							),
   }

def   SCREAMING_SNAKE_CASE_       (  _snake_case  :Union[str, Any]  ,      _snake_case  :Union[str, Any]  ,      _snake_case  :Tuple="exp"  ,      _snake_case  :Dict=None  ,      _snake_case  :List[str]=False  ,      _snake_case  :Union[str, Any]=False  ,      _snake_case  :List[Any]=None  ,      _snake_case  :Tuple=False  ,      )     ->    Tuple:
   # xtreme-s can only have one label
   _A						     =					[[label] for label in labels]
   _A						     =					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"`.'''							)

   _A						     =					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'''							)
   _A						     =					[[refs[i] for refs in labels] for i in range(_snake_case							)]
   _A						     =					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   SCREAMING_SNAKE_CASE_       (  _snake_case  :Optional[Any]  ,      _snake_case  :Optional[int]  ,      _snake_case  :List[Any]  ,      _snake_case  :str							)     ->    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:
      _A						     =					compute_measures(_snake_case  ,      _snake_case							)['''wer''']

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

      def compute_score(_snake_case  :Tuple  ,      _snake_case  :Any  ,      _snake_case  :str="wer"							):
         _A						     =					0
         _A						     =					0
         for prediction, reference in zip(_snake_case  ,      _snake_case							):
            if score_type == "wer":
               _A						     =					compute_measures(_snake_case  ,      _snake_case							)
            elif score_type == "cer":
               _A						     =					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):



 """simple docstring"""

 def 						snake_case_			(						self				:				str			)      ->  List[Any]:
    if self.config_name not in _CONFIG_NAMES:
       raise KeyError(f'''You should supply a configuration name selected in {_CONFIG_NAMES}'''			)

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



