

'''simple docstring'''




import json
import os
from functools import lru_cache
from typing import List, Optional, Tuple

import regex as re

from ...tokenization_utils import AddedToken, PreTrainedTokenizer
from ...utils import logging


_a			:	Optional[int]								=  logging.get_logger(__name__)


_a			:	List[str]								=  {'vocab_file': 'vocab.json', 'merges_file': 'merges.txt'}

# See all MVP models at https://huggingface.co/models?filter=mvp
_a			:	Tuple								=  {
    'vocab_file': {
        'RUCAIBox/mvp': 'https://huggingface.co/RUCAIBox/mvp/resolve/main/vocab.json',
    },
    'added_tokens.json': {
        'RUCAIBox/mvp': 'https://huggingface.co/RUCAIBox/mvp/resolve/main/added_tokens.json',
    },
    'merges_file': {
        'RUCAIBox/mvp': 'https://huggingface.co/RUCAIBox/mvp/resolve/main/merges.txt',
    },
}

_a			:	str								=  {
    'RUCAIBox/mvp': 1024,
}


@lru_cache()
def  lowerCamelCase__						(  ):
  UpperCAmelCase  							=		(
      list(range(ord('!'  )    ,				ord('~'  ) + 1  )  ) + list(range(ord('¡'  )    ,				ord('¬'  ) + 1  )  ) + list(range(ord('®'  )    ,				ord('ÿ'  ) + 1  )  )
  )
  UpperCAmelCase  							=		bs[:]
  UpperCAmelCase  							=		0
  for b in range(2**8  ):
    if b not in bs:
      bs.append(SCREAMING_SNAKE_CASE  )
      cs.append(2**8 + n  )
      n += 1
  UpperCAmelCase  							=		[chr(SCREAMING_SNAKE_CASE  ) for n in cs]
  return dict(zip(SCREAMING_SNAKE_CASE    ,				SCREAMING_SNAKE_CASE  )  )


def  lowerCamelCase__						(  SCREAMING_SNAKE_CASE :				List[Any]  ):
  UpperCAmelCase  							=		set()
  UpperCAmelCase  							=		word[0]
  for char in word[1:]:
    pairs.add((prev_char, char)  )
    UpperCAmelCase  							=		char
  return pairs



class     lowercase_		(						a	):

  '''simple docstring'''





  __lowerCAmelCase   :	str      					=				VOCAB_FILES_NAMES
  __lowerCAmelCase   :	List[Any]      					=				PRETRAINED_VOCAB_FILES_MAP
  __lowerCAmelCase   :	Dict      					=				PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
  __lowerCAmelCase   :	Optional[Any]      					=				["input_ids", "attention_mask"]
  def __init__(       self				,	a_				,	a_				,	a_="replace"				,	a_="<s>"				,	a_="</s>"				,	a_="</s>"				,	a_="<s>"				,	a_="<unk>"				,	a_="<pad>"				,	a_="<mask>"				,	a_=False				,	**a_				,	)							->			Optional[Any]:


    """simple docstring"""
    UpperCAmelCase  							=		AddedToken(a_				,	lstrip=a_				,	rstrip=a_       ) if isinstance(a_				,	a_       ) else bos_token
    UpperCAmelCase  							=		AddedToken(a_				,	lstrip=a_				,	rstrip=a_       ) if isinstance(a_				,	a_       ) else eos_token
    UpperCAmelCase  							=		AddedToken(a_				,	lstrip=a_				,	rstrip=a_       ) if isinstance(a_				,	a_       ) else sep_token
    UpperCAmelCase  							=		AddedToken(a_				,	lstrip=a_				,	rstrip=a_       ) if isinstance(a_				,	a_       ) else cls_token
    UpperCAmelCase  							=		AddedToken(a_				,	lstrip=a_				,	rstrip=a_       ) if isinstance(a_				,	a_       ) else unk_token
    UpperCAmelCase  							=		AddedToken(a_				,	lstrip=a_				,	rstrip=a_       ) if isinstance(a_				,	a_       ) else pad_token

    # Mask token behave like a normal word, i.e. include the space before it
    UpperCAmelCase  							=		AddedToken(a_				,	lstrip=a_				,	rstrip=a_       ) if isinstance(a_				,	a_       ) else mask_token

    super().__init__(
        errors=a_				,	bos_token=a_				,	eos_token=a_				,	unk_token=a_				,	sep_token=a_				,	cls_token=a_				,	pad_token=a_				,	mask_token=a_				,	add_prefix_space=a_				,	**a_				,	)
    with open(a_				,	encoding='utf-8'       ) as vocab_handle:
      UpperCAmelCase  							=		json.load(a_       )
    UpperCAmelCase  							=		{v: k for k, v in self.encoder.items()}
    UpperCAmelCase  							=		errors  # how to handle errors in decoding
    UpperCAmelCase  							=		bytes_to_unicode()
    UpperCAmelCase  							=		{v: k for k, v in self.byte_encoder.items()}
    with open(a_				,	encoding='utf-8'       ) as merges_handle:
      UpperCAmelCase  							=		merges_handle.read().split('\n'       )[1:-1]
    UpperCAmelCase  							=		[tuple(merge.split()       ) for merge in bpe_merges]
    UpperCAmelCase  							=		dict(zip(a_				,	range(len(a_       )       )       )       )
    UpperCAmelCase  							=		{}
    UpperCAmelCase  							=		add_prefix_space

    # Should have added re.IGNORECASE so BPE merges can happen for capitalized versions of contractions
    UpperCAmelCase  							=		re.compile(r'\'s|\'t|\'re|\'ve|\'m|\'ll|\'d| ?\p{L}+| ?\p{N}+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+'       )
  @property
  def   snake_case_     (       self       )							->			Any:


    """simple docstring"""
    return len(self.encoder       )
  def   snake_case_     (       self       )							->			Union[str, Any]:


    """simple docstring"""
    return dict(self.encoder				,	**self.added_tokens_encoder       )
  def   snake_case_     (       self				,	a_       )							->			int:


    """simple docstring"""
    if token in self.cache:
      return self.cache[token]
    UpperCAmelCase  							=		tuple(a_       )
    UpperCAmelCase  							=		get_pairs(a_       )

    if not pairs:
      return token

    while True:
      UpperCAmelCase  							=		min(a_				,	key=lambda a_       : self.bpe_ranks.get(a_				,	float('inf'       )       )       )
      if bigram not in self.bpe_ranks:
        break
      UpperCAmelCase							, UpperCAmelCase  							=		bigram
      UpperCAmelCase  							=		[]
      UpperCAmelCase  							=		0
      while i < len(a_       ):
        try:
          UpperCAmelCase  							=		word.index(a_				,	a_       )
        except ValueError:
          new_word.extend(word[i:]       )
          break
        else:
          new_word.extend(word[i:j]       )
          UpperCAmelCase  							=		j

        if word[i] == first and i < len(a_       ) - 1 and word[i + 1] == second:
          new_word.append(first + second       )
          i += 2
        else:
          new_word.append(word[i]       )
          i += 1
      UpperCAmelCase  							=		tuple(a_       )
      UpperCAmelCase  							=		new_word
      if len(a_       ) == 1:
        break
      else:
        UpperCAmelCase  							=		get_pairs(a_       )
    UpperCAmelCase  							=		' '.join(a_       )
    UpperCAmelCase  							=		word
    return word
  def   snake_case_     (       self				,	a_       )							->			int:


    """simple docstring"""
    UpperCAmelCase  							=		[]
    for token in re.findall(self.pat				,	a_       ):
      UpperCAmelCase  							=		''.join(
          self.byte_encoder[b] for b in token.encode('utf-8'       )       )  # Maps all our bytes to unicode strings, avoiding control tokens of the BPE (spaces in our case)
      bpe_tokens.extend(bpe_token for bpe_token in self.bpe(a_       ).split(' '       )       )
    return bpe_tokens
  def   snake_case_     (       self				,	a_       )							->			Optional[int]:


    """simple docstring"""
    return self.encoder.get(a_				,	self.encoder.get(self.unk_token       )       )
  def   snake_case_     (       self				,	a_       )							->			Tuple:


    """simple docstring"""
    return self.decoder.get(a_       )
  def   snake_case_     (       self				,	a_       )							->			List[Any]:


    """simple docstring"""
    UpperCAmelCase  							=		''.join(a_       )
    UpperCAmelCase  							=		bytearray([self.byte_decoder[c] for c in text]       ).decode('utf-8'				,	errors=self.errors       )
    return text
  def   snake_case_     (       self				,	a_				,	a_ = None       )							->			Tuple[str]:


    """simple docstring"""
    if not os.path.isdir(a_       ):
      logger.error(F'''Vocabulary path ({save_directory}) should be a directory'''       )
      return
    UpperCAmelCase  							=		os.path.join(
        a_				,	(filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['vocab_file']       )
    UpperCAmelCase  							=		os.path.join(
        a_				,	(filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['merges_file']       )

    with open(a_				,	'w'				,	encoding='utf-8'       ) as f:
      f.write(json.dumps(self.encoder				,	indent=2				,	sort_keys=a_				,	ensure_ascii=a_       ) + '\n'       )

    UpperCAmelCase  							=		0
    with open(a_				,	'w'				,	encoding='utf-8'       ) as writer:
      writer.write('#version: 0.2\n'       )
      for bpe_tokens, token_index in sorted(self.bpe_ranks.items()				,	key=lambda a_       : kv[1]       ):
        if index != token_index:
          logger.warning(
              F'''Saving vocabulary to {merge_file}: BPE merge indices are not consecutive.'''
              ' Please check that the tokenizer is not corrupted!'       )
          UpperCAmelCase  							=		token_index
        writer.write(' '.join(a_       ) + '\n'       )
        index += 1

    return vocab_file, merge_file
  def   snake_case_     (       self				,	a_				,	a_ = None       )							->			List[int]:


    """simple docstring"""
    if token_ids_a is None:
      return [self.cls_token_id] + token_ids_a + [self.sep_token_id]
    UpperCAmelCase  							=		[self.cls_token_id]
    UpperCAmelCase  							=		[self.sep_token_id]
    return cls + token_ids_a + sep + sep + token_ids_a + sep
  def   snake_case_     (       self				,	a_				,	a_ = None				,	a_ = False       )							->			List[int]:


    """simple docstring"""
    if already_has_special_tokens:
      return super().get_special_tokens_mask(
          token_ids_a=a_				,	token_ids_a=a_				,	already_has_special_tokens=a_       )

    if token_ids_a is None:
      return [1] + ([0] * len(a_       )) + [1]
    return [1] + ([0] * len(a_       )) + [1, 1] + ([0] * len(a_       )) + [1]
  def   snake_case_     (       self				,	a_				,	a_ = None       )							->			List[int]:


    """simple docstring"""
    UpperCAmelCase  							=		[self.sep_token_id]
    UpperCAmelCase  							=		[self.cls_token_id]

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





  def   snake_case_     (       self				,	a_				,	a_=False				,	**a_       )							->			Optional[Any]:


    """simple docstring"""
    UpperCAmelCase  							=		kwargs.pop('add_prefix_space'				,	self.add_prefix_space       )
    if (is_split_into_words or add_prefix_space) and (len(a_       ) > 0 and not text[0].isspace()):
      UpperCAmelCase  							=		' ' + text
    return (text, kwargs)





'''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)
_a			:	List[Any]								=  '\\n'

_a			:	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'

_a			:	Dict								=  '\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'

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

try:
  from jiwer import transforms as tr

  _a			:	Optional[Any]								=  True
except ImportError:
  _a			:	List[Any]								=  False

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



  class     lowercase_		(						tr.AbstractTransform	):

    '''simple docstring'''





    def __init__(       self				,	a_ = " "       )							->			str:


      """simple docstring"""
      UpperCAmelCase  							=		sentence_delimiter
    def   snake_case_     (       self				,	a_       )							->			Optional[int]:


      """simple docstring"""
      return list(a_       )





    def   snake_case_     (       self				,	a_       )							->			List[str]:


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




  _a			:	List[Any]								=  tr.Compose(
      [tr.RemoveMultipleSpaces(), tr.Strip(), SentencesToListOfCharacters(SENTENCE_DELIMITER)]
  )
elif _jiwer_available:
  _a			:	int								=  tr.Compose(
      [
          tr.RemoveMultipleSpaces(),
          tr.Strip(),
          tr.ReduceToSingleSentence(SENTENCE_DELIMITER),
          tr.ReduceToListOfListOfChars(),
      ]
  )
else:
  _a			:	Optional[int]								=  None


def  lowerCamelCase__						(  SCREAMING_SNAKE_CASE :				List[str]    ,				SCREAMING_SNAKE_CASE :				Union[str, Any]  ):
  return float((preds == labels).mean()  )


def  lowerCamelCase__						(  SCREAMING_SNAKE_CASE :				int    ,				SCREAMING_SNAKE_CASE :				Optional[Any]  ):
  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  lowerCamelCase__						(  SCREAMING_SNAKE_CASE :				Optional[int]    ,				SCREAMING_SNAKE_CASE :				int    ,				SCREAMING_SNAKE_CASE :				str="exp"    ,				SCREAMING_SNAKE_CASE :				Union[str, Any]=None    ,				SCREAMING_SNAKE_CASE :				Any=False    ,				SCREAMING_SNAKE_CASE :				Optional[Any]=False    ,				SCREAMING_SNAKE_CASE :				Optional[int]=None    ,				SCREAMING_SNAKE_CASE :				List[Any]=False    ,				):
  # xtreme-s can only have one label
  UpperCAmelCase  							=		[[label] for label in labels]
  UpperCAmelCase  							=		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  							=		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  							=		[[refs[i] for refs in labels] for i in range(SCREAMING_SNAKE_CASE  )]
  UpperCAmelCase  							=		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  lowerCamelCase__						(  SCREAMING_SNAKE_CASE :				List[str]    ,				SCREAMING_SNAKE_CASE :				Tuple    ,				SCREAMING_SNAKE_CASE :				Optional[Any]    ,				SCREAMING_SNAKE_CASE :				Optional[int]  ):
  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  							=		compute_measures(SCREAMING_SNAKE_CASE    ,				SCREAMING_SNAKE_CASE  )['wer']

    UpperCAmelCase  							=		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 :				Union[str, Any]    ,				SCREAMING_SNAKE_CASE :				List[Any]    ,				SCREAMING_SNAKE_CASE :				List[str]="wer"  ):
      UpperCAmelCase  							=		0
      UpperCAmelCase  							=		0
      for prediction, reference in zip(SCREAMING_SNAKE_CASE    ,				SCREAMING_SNAKE_CASE  ):
        if score_type == "wer":
          UpperCAmelCase  							=		compute_measures(SCREAMING_SNAKE_CASE    ,				SCREAMING_SNAKE_CASE  )
        elif score_type == "cer":
          UpperCAmelCase  							=		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     lowercase_		(						datasets.Metric	):

  '''simple docstring'''





  def   snake_case_     (       self       )							->			Tuple:


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

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





  def   snake_case_     (       self				,	a_				,	a_				,	a_=None				,	a_=None       )							->			Dict:


    """simple docstring"""
    UpperCAmelCase  							=		bleu_kwargs if bleu_kwargs is not None else {}
    UpperCAmelCase  							=		wer_kwargs if wer_kwargs is not None else {}

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


