






"""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)
_UpperCamelCase						:    str		=						'\\n'

_UpperCamelCase						:    Tuple		=						'\\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'

_UpperCamelCase						:    int		=						'\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'

_UpperCamelCase						:    Dict		=						['fleurs-asr', 'mls', 'voxpopuli', 'babel', 'covost2', 'fleurs-lang_id', 'minds14']
_UpperCamelCase						:    int		=						''

try:
    from jiwer import transforms as tr

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

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

    class 			a	(  tr.AbstractTransform      ):







        def __init__(     self				,						_lowerCamelCase = " "			):
          lowercase				       =			sentence_delimiter







        def      UpperCamelCase_ (     self				,						_lowerCamelCase			):
          return list(_SCREAMING_SNAKE_CASE			)







        def      UpperCamelCase_ (     self				,						_lowerCamelCase			):
          lowercase				       =			[]
          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


    _UpperCamelCase						:    Tuple		=						tr.Compose(
        [tr.RemoveMultipleSpaces(), tr.Strip(), SentencesToListOfCharacters(SENTENCE_DELIMITER)]
    )
elif _jiwer_available:
    _UpperCamelCase						:    Any		=						tr.Compose(
        [
            tr.RemoveMultipleSpaces(),
            tr.Strip(),
            tr.ReduceToSingleSentence(SENTENCE_DELIMITER),
            tr.ReduceToListOfListOfChars(),
        ]
    )
else:
    _UpperCamelCase						:    Tuple		=						None
def 		_SCREAMING_SNAKE_CASE					(       __snake_case     :    List[str]						,   __snake_case     :    str       ):





  '''simple docstring'''





  return float((preds == labels).mean()       )
def 		_SCREAMING_SNAKE_CASE					(       __snake_case     :    Tuple						,   __snake_case     :    Union[str, Any]       ):





  '''simple docstring'''





  return {
      "f1": float(fa_score(y_true=UpperCAmelCase__						,   y_pred=UpperCAmelCase__						,   average='macro'       )       ),
      "accuracy": simple_accuracy(UpperCAmelCase__						,   UpperCAmelCase__       ),
  }
def 		_SCREAMING_SNAKE_CASE					(       __snake_case     :    List[Any]						,   __snake_case     :    Dict						,   __snake_case     :    Dict="exp"						,   __snake_case     :    Tuple=None						,   __snake_case     :    Dict=False						,   __snake_case     :    Any=False						,   __snake_case     :    List[Any]=None						,   __snake_case     :    Any=False						,   ):





  '''simple docstring'''





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

  lowercase				       =			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'       )
  lowercase				       =			[[refs[i] for refs in labels] for i in range(UpperCAmelCase__       )]
  lowercase				       =			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 		_SCREAMING_SNAKE_CASE					(       __snake_case     :    Union[str, Any]						,   __snake_case     :    str						,   __snake_case     :    Any						,   __snake_case     :    Dict       ):





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

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

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







    def      UpperCamelCase_ (     self			):






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

      lowercase				       =			"""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      UpperCamelCase_ (     self				,						_lowerCamelCase				,						_lowerCamelCase				,						_lowerCamelCase=None				,						_lowerCamelCase=None			):
      lowercase				       =			bleu_kwargs if bleu_kwargs is not None else {}
      lowercase				       =			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				       =			bleu_kwargs.pop('smooth_method'				,						'exp'			)
        lowercase				       =			bleu_kwargs.pop('smooth_value'				,						_SCREAMING_SNAKE_CASE			)
        lowercase				       =			bleu_kwargs.pop('force'				,						_SCREAMING_SNAKE_CASE			)
        lowercase				       =			bleu_kwargs.pop('lowercase'				,						_SCREAMING_SNAKE_CASE			)
        lowercase				       =			bleu_kwargs.pop('tokenize'				,						_SCREAMING_SNAKE_CASE			)
        lowercase				       =			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				       =			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'''


import os
from shutil import copyfile
from typing import List, Optional, Tuple

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import is_sentencepiece_available, logging


if is_sentencepiece_available():
	from .tokenization_xglm import XGLMTokenizer
else:
	__SCREAMING_SNAKE_CASE						=      None


__SCREAMING_SNAKE_CASE						=      logging.get_logger(__name__)

__SCREAMING_SNAKE_CASE						=      {"vocab_file": "sentencepiece.bpe.model", "tokenizer_file": "tokenizer.json"}

__SCREAMING_SNAKE_CASE						=      {
    "vocab_file": {
        "facebook/xglm-564M": "https://huggingface.co/facebook/xglm-564M/resolve/main/sentencepiece.bpe.model",
    },
    "tokenizer_file": {
        "facebook/xglm-564M": "https://huggingface.co/facebook/xglm-564M/resolve/main/tokenizer.json",
    },
}

__SCREAMING_SNAKE_CASE						=      {
    "facebook/xglm-564M": 2048,
}




class     __snake_case			(    _a	):
		a_          =					VOCAB_FILES_NAMES
		a_          =					PRETRAINED_VOCAB_FILES_MAP
		a_          =					PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
		a_          =					["input_ids", "attention_mask"]
		a_          =					XGLMTokenizer




		def __init__(  self					:str			,    _SCREAMING_SNAKE_CASE					:Dict=None			,    _SCREAMING_SNAKE_CASE					:List[str]=None			,    _SCREAMING_SNAKE_CASE					:Dict="<s>"			,    _SCREAMING_SNAKE_CASE					:Dict="</s>"			,    _SCREAMING_SNAKE_CASE					:List[Any]="</s>"			,    _SCREAMING_SNAKE_CASE					:Tuple="<s>"			,    _SCREAMING_SNAKE_CASE					:int="<unk>"			,    _SCREAMING_SNAKE_CASE					:List[str]="<pad>"			,    **_SCREAMING_SNAKE_CASE					:Optional[int]			,    )					->			Optional[int]:






								'''simple docstring'''






								UpperCamelCase_     :	Tuple					     =     7
								UpperCamelCase_     :	int					     =     [F"""<madeupword{i}>""" for i in range(self.num_madeup_words)]

								UpperCamelCase_     :	Optional[Any]					     =     kwargs.get("""additional_special_tokens"""			,    [])
								kwargs["additional_special_tokens"] += [
								    word for word in madeup_words if word not in kwargs["additional_special_tokens"]
								]

								super().__init__(
								    _SCREAMING_SNAKE_CASE			,    tokenizer_file=_SCREAMING_SNAKE_CASE			,    bos_token=_SCREAMING_SNAKE_CASE			,    eos_token=_SCREAMING_SNAKE_CASE			,    sep_token=_SCREAMING_SNAKE_CASE			,    cls_token=_SCREAMING_SNAKE_CASE			,    unk_token=_SCREAMING_SNAKE_CASE			,    pad_token=_SCREAMING_SNAKE_CASE			,    **_SCREAMING_SNAKE_CASE			,    )

								UpperCamelCase_     :	int					     =     vocab_file
								UpperCamelCase_     :	Any					     =     False if not self.vocab_file else True




		def 	_snake_case	(  self					:Dict			,    _SCREAMING_SNAKE_CASE					:List[int]			,    _SCREAMING_SNAKE_CASE					:Optional[List[int]] = None)					->			List[int]:






								'''simple docstring'''






								if token_ids_a is None:
														return [self.sep_token_id] + token_ids_a
								UpperCamelCase_     :	str					     =     [self.sep_token_id]
								return sep + token_ids_a + sep + sep + token_ids_a




		def 	_snake_case	(  self					:int			,    _SCREAMING_SNAKE_CASE					:List[int]			,    _SCREAMING_SNAKE_CASE					:Optional[List[int]] = None)					->			List[int]:






								'''simple docstring'''






								UpperCamelCase_     :	Optional[Any]					     =     [self.sep_token_id]

								if token_ids_a is None:
														return len(sep + token_ids_a) * [0]
								return len(sep + token_ids_a + sep + sep + token_ids_a) * [0]





		def 	_snake_case	(  self					:List[Any]			,    _SCREAMING_SNAKE_CASE					:str			,    _SCREAMING_SNAKE_CASE					:Optional[str] = None)					->			Tuple[str]:






								'''simple docstring'''






								if not self.can_save_slow_tokenizer:
														raise ValueError(
														    """Your fast tokenizer does not have the necessary information to save the vocabulary for a slow """
														    """tokenizer.""")

								if not os.path.isdir(_SCREAMING_SNAKE_CASE):
														logger.error(F"""Vocabulary path ({save_directory}) should be a directory.""")
														return
								UpperCamelCase_     :	Dict					     =     os.path.join(
								    _SCREAMING_SNAKE_CASE			,    (filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab_file"""])

								if os.path.abspath(self.vocab_file) != os.path.abspath(_SCREAMING_SNAKE_CASE):
														copyfile(self.vocab_file			,    _SCREAMING_SNAKE_CASE)

								return (out_vocab_file,)




