


import copy
import os
from typing import Dict, Optional, Union

from ...configuration_utils import PretrainedConfig
from ...utils import add_start_docstrings, logging
from ..auto import AutoConfig


__lowerCamelCase   	=  logging.get_logger(__name__)


__lowerCamelCase   	=  {
    "suno/bark-small": "https://huggingface.co/suno/bark-small/resolve/main/config.json",
    "suno/bark": "https://huggingface.co/suno/bark/resolve/main/config.json",
}

__lowerCamelCase   	=  "\n    This is the configuration class to store the configuration of a [`{model}`]. It is used to instantiate the model\n    according to the specified arguments, defining the model architecture. Instantiating a configuration with the\n    defaults will yield a similar configuration to that of the Bark [suno/bark](https://huggingface.co/suno/bark)\n    architecture.\n\n    Configuration objects inherit from [`PretrainedConfig`] and can be used to control the model outputs. Read the\n    documentation from [`PretrainedConfig`] for more information.\n\n    Args:\n        block_size (`int`, *optional*, defaults to 1024):\n            The maximum sequence length that this model might ever be used with. Typically set this to something large\n            just in case (e.g., 512 or 1024 or 2048).\n        input_vocab_size (`int`, *optional*, defaults to 10_048):\n            Vocabulary size of a Bark sub-model. Defines the number of different tokens that can be represented by the\n            `inputs_ids` passed when calling [`{model}`]. Defaults to 10_048 but should be carefully thought with\n            regards to the chosen sub-model.\n        output_vocab_size (`int`, *optional*, defaults to 10_048):\n            Output vocabulary size of a Bark sub-model. Defines the number of different tokens that can be represented\n            by the: `output_ids` when passing forward a [`{model}`]. Defaults to 10_048 but should be carefully thought\n            with regards to the chosen sub-model.\n        num_layers (`int`, *optional*, defaults to 12):\n            Number of hidden layers in the given sub-model.\n        num_heads (`int`, *optional*, defaults to 12):\n            Number of attention heads for each attention layer in the Transformer architecture.\n        hidden_size (`int`, *optional*, defaults to 768):\n            Dimensionality of the \"intermediate\" (often named feed-forward) layer in the architecture.\n        dropout (`float`, *optional*, defaults to 0.0):\n            The dropout probability for all fully connected layers in the embeddings, encoder, and pooler.\n        bias (`bool`, *optional*, defaults to `True`):\n            Whether or not to use bias in the linear layers and layer norm layers.\n        initializer_range (`float`, *optional*, defaults to 0.02):\n            The standard deviation of the truncated_normal_initializer for initializing all weight matrices.\n        use_cache (`bool`, *optional*, defaults to `True`):\n            Whether or not the model should return the last key/values attentions (not used by all models).\n"


class 	a__						(    _a     ):
       lowerCamelCase__:  Tuple				     =  "bark_module"
       lowerCamelCase__:  Optional[int]				     =  ["past_key_values"]

       lowerCamelCase__:  Tuple				     =  {
           "num_attention_heads": "num_heads",
           "num_hidden_layers": "num_layers",
           "vocab_size": "input_vocab_size",
           "window_size": "block_size",
       }

       def __init__( self   :  int   ,				lowerCamelCase_   :  Union[str, Any]=1_0_2_4   ,				lowerCamelCase_   :  int=1_0_0_4_8   ,				lowerCamelCase_   :  Any=1_0_0_4_8   ,				lowerCamelCase_   :  List[str]=1_2   ,				lowerCamelCase_   :  Dict=1_2   ,				lowerCamelCase_   :  List[str]=7_6_8   ,				lowerCamelCase_   :  str=0.0   ,				lowerCamelCase_   :  Any=True   ,				lowerCamelCase_   :  List[str]=0.0_2   ,				lowerCamelCase_   :  Tuple=True   ,				**lowerCamelCase_   :  Optional[Any]   ,				):
            a_     :  int				      =     block_size
            a_     :  Optional[int]				      =     input_vocab_size
            a_     :  str				      =     output_vocab_size
            a_     :  Optional[int]				      =     num_layers
            a_     :  str				      =     num_heads
            a_     :  Any				      =     hidden_size
            a_     :  Optional[int]				      =     dropout
            a_     :  Any				      =     bias
            a_     :  Optional[Any]				      =     use_cache
            a_     :  Any				      =     initializer_range

            super().__init__(**__SCREAMING_SNAKE_CASE     )

       @classmethod
       def     UpperCAmelCase( cls   :  Union[str, Any]   ,				lowerCamelCase_   :  Tuple   ,				lowerCamelCase_   :  List[str] = None   ,				lowerCamelCase_   :  Any = False   ,				lowerCamelCase_   :  List[str] = False   ,				lowerCamelCase_   :  Tuple = None   ,				lowerCamelCase_   :  List[Any] = "main"   ,				**lowerCamelCase_   :  List[str]   ,				):
            a_     :  Optional[Any]				      =     cache_dir
            a_     :  Union[str, Any]				      =     force_download
            a_     :  Tuple				      =     local_files_only
            a_     :  int				      =     revision

            cls._set_token_in_kwargs(__SCREAMING_SNAKE_CASE   ,				__SCREAMING_SNAKE_CASE     )

            a_     :  List[str]				      =     cls.get_config_dict(__SCREAMING_SNAKE_CASE   ,				**__SCREAMING_SNAKE_CASE     )

            # get the config dict if we are loading from Bark
            if config_dict.get("""model_type"""     ) == "bark":
                 a_     :  List[Any]				      =     config_dict[F'''{cls.model_type}_config''']

            if "model_type" in config_dict and hasattr(cls   ,				"""model_type"""     ) and config_dict["model_type"] != cls.model_type:
                 logger.warning(
                     F'''You are using a model of type {config_dict["model_type"]} to instantiate a model of type '''
                     F'''{cls.model_type}. This is not supported for all configurations of models and can yield errors.'''     )

            return cls.from_dict(__SCREAMING_SNAKE_CASE   ,				**__SCREAMING_SNAKE_CASE     )


@add_start_docstrings(
    BARK_SUBMODELCONFIG_START_DOCSTRING.format(config="""BarkSemanticConfig"""    ,							model="""BarkSemanticModel"""     )    ,							"""\n    Example:\n\n    ```python\n    >>> from transformers import BarkSemanticConfig, BarkSemanticModel\n\n    >>> # Initializing a Bark sub-module style configuration\n    >>> configuration = BarkSemanticConfig()\n\n    >>> # Initializing a model (with random weights) from the suno/bark style configuration\n    >>> model = BarkSemanticModel(configuration)\n\n    >>> # Accessing the model configuration\n    >>> configuration = model.config\n    ```"""    ,							)
class 	a__						(    _a     ):
       lowerCamelCase__:  List[str]				     =  "semantic"


@add_start_docstrings(
    BARK_SUBMODELCONFIG_START_DOCSTRING.format(config="""BarkCoarseConfig"""    ,							model="""BarkCoarseModel"""     )    ,							"""\n    Example:\n\n    ```python\n    >>> from transformers import BarkCoarseConfig, BarkCoarseModel\n\n    >>> # Initializing a Bark sub-module style configuration\n    >>> configuration = BarkCoarseConfig()\n\n    >>> # Initializing a model (with random weights) from the suno/bark style configuration\n    >>> model = BarkCoarseModel(configuration)\n\n    >>> # Accessing the model configuration\n    >>> configuration = model.config\n    ```"""    ,							)
class 	a__						(    _a     ):
       lowerCamelCase__:  Optional[int]				     =  "coarse_acoustics"


@add_start_docstrings(
    BARK_SUBMODELCONFIG_START_DOCSTRING.format(config="""BarkFineConfig"""    ,							model="""BarkFineModel"""     )    ,							"""\n        n_codes_total (`int`, *optional*, defaults to 8):\n            The total number of audio codebooks predicted. Used in the fine acoustics sub-model.\n        n_codes_given (`int`, *optional*, defaults to 1):\n            The number of audio codebooks predicted in the coarse acoustics sub-model. Used in the acoustics\n            sub-models.\n    Example:\n\n    ```python\n    >>> from transformers import BarkFineConfig, BarkFineModel\n\n    >>> # Initializing a Bark sub-module style configuration\n    >>> configuration = BarkFineConfig()\n\n    >>> # Initializing a model (with random weights) from the suno/bark style configuration\n    >>> model = BarkFineModel(configuration)\n\n    >>> # Accessing the model configuration\n    >>> configuration = model.config\n    ```"""    ,							)
class 	a__						(    _a     ):
       lowerCamelCase__:  int				     =  "fine_acoustics"

       def __init__( self   :  Optional[Any]   ,				lowerCamelCase_   :  List[Any]=True   ,				lowerCamelCase_   :  Optional[Any]=8   ,				lowerCamelCase_   :  str=1   ,				**lowerCamelCase_   :  List[Any]     ):
            a_     :  Dict				      =     n_codes_total
            a_     :  str				      =     n_codes_given

            super().__init__(tie_word_embeddings=__SCREAMING_SNAKE_CASE   ,				**__SCREAMING_SNAKE_CASE     )


class 	a__						(    _a     ):
       lowerCamelCase__:  Optional[int]				     =  "bark"
       lowerCamelCase__:  List[str]				     =  True

       def __init__( self   :  Tuple   ,				lowerCamelCase_   :  Optional[Any] = None   ,				lowerCamelCase_   :  Dict = None   ,				lowerCamelCase_   :  int = None   ,				lowerCamelCase_   :  int = None   ,				lowerCamelCase_   :  Tuple=0.0_2   ,				**lowerCamelCase_   :  str   ,				):




            if semantic_config is None:
                 a_     :  Dict				      =     {}
                 logger.info("""semantic_config is None. initializing the semantic model with default values."""     )

            if coarse_acoustics_config is None:
                 a_     :  Any				      =     {}
                 logger.info("""coarse_acoustics_config is None. initializing the coarse model with default values."""     )

            if fine_acoustics_config is None:
                 a_     :  List[str]				      =     {}
                 logger.info("""fine_acoustics_config is None. initializing the fine model with default values."""     )

            if codec_config is None:
                 a_     :  Any				      =     {}
                 logger.info("""codec_config is None. initializing the codec model with default values."""     )

            a_     :  Optional[Any]				      =     BarkSemanticConfig(**__SCREAMING_SNAKE_CASE     )
            a_     :  int				      =     BarkCoarseConfig(**__SCREAMING_SNAKE_CASE     )
            a_     :  Any				      =     BarkFineConfig(**__SCREAMING_SNAKE_CASE     )
            a_     :  Any				      =     AutoConfig.for_model(**__SCREAMING_SNAKE_CASE     )

            a_     :  Dict				      =     initializer_range

            super().__init__(**__SCREAMING_SNAKE_CASE     )

       @classmethod
       def     UpperCAmelCase( cls   :  Union[str, Any]   ,				lowerCamelCase_   :  Optional[Any]   ,				lowerCamelCase_   :  Dict   ,				lowerCamelCase_   :  Tuple   ,				lowerCamelCase_   :  List[Any]   ,				**lowerCamelCase_   :  Any   ,				):
            return cls(
                semantic_config=semantic_config.to_dict()   ,				coarse_acoustics_config=coarse_acoustics_config.to_dict()   ,				fine_acoustics_config=fine_acoustics_config.to_dict()   ,				codec_config=codec_config.to_dict()   ,				**__SCREAMING_SNAKE_CASE   ,				)

       def     UpperCAmelCase( self   :  Union[str, Any]     ):
            a_     :  Optional[int]				      =     copy.deepcopy(self.__dict__     )

            a_     :  Any				      =     self.semantic_config.to_dict()
            a_     :  Any				      =     self.coarse_acoustics_config.to_dict()
            a_     :  Tuple				      =     self.fine_acoustics_config.to_dict()
            a_     :  int				      =     self.codec_config.to_dict()

            a_     :  int				      =     self.__class__.model_type
            return output







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			:			Union[str, Any]			      =					"\\n"

__UpperCAmelCase			:			Optional[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"

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

try:
  from jiwer import transforms as tr

  __UpperCAmelCase			:			Optional[int]			      =					True
except ImportError:
  __UpperCAmelCase			:			str			      =					False

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



  class  UpperCAmelCase_						(				tr.AbstractTransform):
         '''simple docstring'''






         def __init__(  self			,       __SCREAMING_SNAKE_CASE = " "    ):




                """simple docstring"""




                UpperCamelCase     :						List[str] 						=		sentence_delimiter






         def 			_lowercase (  self			,       __SCREAMING_SNAKE_CASE    ):




                """simple docstring"""




                return list(__SCREAMING_SNAKE_CASE    )






         def 			_lowercase (  self			,       __SCREAMING_SNAKE_CASE    ):




                """simple docstring"""




                UpperCamelCase     :						Dict 						=		[]
                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			:			Optional[Any]			      =					tr.Compose(
      [tr.RemoveMultipleSpaces(), tr.Strip(), SentencesToListOfCharacters(SENTENCE_DELIMITER)]
  )
elif _jiwer_available:
  __UpperCAmelCase			:			int			      =					tr.Compose(
      [
          tr.RemoveMultipleSpaces(),
          tr.Strip(),
          tr.ReduceToSingleSentence(SENTENCE_DELIMITER),
          tr.ReduceToListOfListOfChars(),
      ]
  )
else:
  __UpperCAmelCase			:			List[Any]			      =					None


def   a						(				SCREAMING_SNAKE_CASE_   :		str				,      SCREAMING_SNAKE_CASE_   :		Union[str, Any]							):






       """simple docstring"""





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


def   a						(				SCREAMING_SNAKE_CASE_   :		int				,      SCREAMING_SNAKE_CASE_   :		Dict							):






       """simple docstring"""





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


def   a						(				SCREAMING_SNAKE_CASE_   :		Any				,      SCREAMING_SNAKE_CASE_   :		Union[str, Any]				,      SCREAMING_SNAKE_CASE_   :		Optional[Any]="exp"				,      SCREAMING_SNAKE_CASE_   :		Any=None				,      SCREAMING_SNAKE_CASE_   :		Any=False				,      SCREAMING_SNAKE_CASE_   :		List[str]=False				,      SCREAMING_SNAKE_CASE_   :		Dict=None				,      SCREAMING_SNAKE_CASE_   :		Tuple=False				,      ):






       """simple docstring"""





       UpperCamelCase     :						str 						=		[[label] for label in labels]
       UpperCamelCase     :						int 						=		list(SCREAMING_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"`.'''							)

       UpperCamelCase     :						Optional[int] 						=		len(labels[0]							)
       if any(len(SCREAMING_SNAKE_CASE_							) != references_per_prediction for refs in labels							):
              raise ValueError('''Sacrebleu requires the same number of references for each prediction'''							)
       UpperCamelCase     :						Optional[Any] 						=		[[refs[i] for refs in labels] for i in range(SCREAMING_SNAKE_CASE_							)]
       UpperCamelCase     :						Optional[Any] 						=		scb.corpus_bleu(
           SCREAMING_SNAKE_CASE_				,      SCREAMING_SNAKE_CASE_				,      smooth_method=SCREAMING_SNAKE_CASE_				,      smooth_value=SCREAMING_SNAKE_CASE_				,      force=SCREAMING_SNAKE_CASE_				,      lowercase=SCREAMING_SNAKE_CASE_				,      use_effective_order=SCREAMING_SNAKE_CASE_				,      **({'''tokenize''': tokenize} if tokenize else {})				,      )
       return {"bleu": output.score}


def   a						(				SCREAMING_SNAKE_CASE_   :		Any				,      SCREAMING_SNAKE_CASE_   :		Tuple				,      SCREAMING_SNAKE_CASE_   :		Tuple				,      SCREAMING_SNAKE_CASE_   :		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:
              UpperCamelCase     :						List[Any] 						=		compute_measures(SCREAMING_SNAKE_CASE_				,      SCREAMING_SNAKE_CASE_							)['''wer''']

              UpperCamelCase     :						List[str] 						=		compute_measures(SCREAMING_SNAKE_CASE_				,      SCREAMING_SNAKE_CASE_				,      truth_transform=SCREAMING_SNAKE_CASE_				,      hypothesis_transform=SCREAMING_SNAKE_CASE_							)['''wer''']
              return {"wer": wer, "cer": cer}
       else:

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

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



@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION,  _KWARGS_DESCRIPTION)
class  UpperCAmelCase_						(				datasets.Metric):
       '''simple docstring'''






       def 			_lowercase (  self    ):




              """simple docstring"""




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

              UpperCamelCase     :						Optional[Any] 						=		'''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 			_lowercase (  self			,       __SCREAMING_SNAKE_CASE			,       __SCREAMING_SNAKE_CASE			,       __SCREAMING_SNAKE_CASE=None			,       __SCREAMING_SNAKE_CASE=None    ):




              """simple docstring"""




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

