



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)
__magic_name__       =     """\
"""

__magic_name__       =     """\
    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.
"""

__magic_name__       =     """
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}
"""

__magic_name__       =     ["""fleurs-asr""", """mls""", """voxpopuli""", """babel""", """covost2""", """fleurs-lang_id""", """minds14"""]
__magic_name__       =     """"""

try:
		from jiwer import transforms as tr

		__magic_name__       =     True
except ImportError:
		__magic_name__       =     False

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


		class 	a__       (       tr.AbstractTransform       ):


							"""simple docstring"""



							def __init__(		self     :Union[str, Any]      ,  lowercase__     :str = " "    ):
												lowercase						   =       sentence_delimiter

							def 				__UpperCAmelCase		(		self     :Dict      ,  lowercase__     :str    ):
												return list(_lowercase    )



							def 				__UpperCAmelCase		(		self     :List[str]      ,  lowercase__     :List[str]    ):
												lowercase						   =       []
												for sent_idx, sentence in enumerate(_lowercase    ):
																	chars.extend(self.process_string(_lowercase    )    )
																	if self.sentence_delimiter is not None and self.sentence_delimiter != "" and sent_idx < len(_lowercase    ) - 1:
																						chars.append(self.sentence_delimiter    )
												return chars




		__magic_name__       =     tr.Compose(
		    [tr.RemoveMultipleSpaces(), tr.Strip(), SentencesToListOfCharacters(SENTENCE_DELIMITER)]
		)
elif _jiwer_available:
		__magic_name__       =     tr.Compose(
		    [
		        tr.RemoveMultipleSpaces(),
		        tr.Strip(),
		        tr.ReduceToSingleSentence(SENTENCE_DELIMITER),
		        tr.ReduceToListOfListOfChars(),
		    ]
		)
else:
		__magic_name__       =     None





def 		__snake_case						(    _UpperCAmelCase       ,			_UpperCAmelCase				):
					"""simple docstring"""






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





def 		__snake_case						(    _UpperCAmelCase       ,			_UpperCAmelCase				):
					"""simple docstring"""






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





def 		__snake_case						(    _UpperCAmelCase       ,			_UpperCAmelCase       ,			_UpperCAmelCase="exp"       ,			_UpperCAmelCase=None       ,			_UpperCAmelCase=False       ,			_UpperCAmelCase=False       ,			_UpperCAmelCase=None       ,			_UpperCAmelCase=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 		__snake_case						(    _UpperCAmelCase       ,			_UpperCAmelCase       ,			_UpperCAmelCase       ,			_UpperCAmelCase				):
					"""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(_UpperCAmelCase       ,			_UpperCAmelCase       ,			_UpperCAmelCase="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       ):


					"""simple docstring"""



					def 				__UpperCAmelCase		(		self     :str    ):
										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(_lowercase    ), 'references': datasets.Value(_lowercase    )}    )      ,  codebase_urls=[]      ,  reference_urls=[]      ,  format='numpy'      ,  )



					def 				__UpperCAmelCase		(		self     :Dict      ,  lowercase__     :Any      ,  lowercase__     :Optional[Any]      ,  lowercase__     :Dict=None      ,  lowercase__     :Any=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(_lowercase      ,  _lowercase    )}
										elif self.config_name == "minds14":
															return fa_and_simple_accuracy(_lowercase      ,  _lowercase    )
										elif self.config_name == "covost2":
															lowercase						   =       bleu_kwargs.pop('smooth_method'      ,  'exp'    )
															lowercase						   =       bleu_kwargs.pop('smooth_value'      ,  _lowercase    )
															lowercase						   =       bleu_kwargs.pop('force'      ,  _lowercase    )
															lowercase						   =       bleu_kwargs.pop('lowercase'      ,  _lowercase    )
															lowercase						   =       bleu_kwargs.pop('tokenize'      ,  _lowercase    )
															lowercase						   =       bleu_kwargs.pop('use_effective_order'      ,  _lowercase    )
															return bleu(
															    preds=_lowercase      ,  labels=_lowercase      ,  smooth_method=_lowercase      ,  smooth_value=_lowercase      ,  force=_lowercase      ,  lowercase=_lowercase      ,  tokenize=_lowercase      ,  use_effective_order=_lowercase      ,  )
										elif self.config_name in ["fleurs-asr", "mls", "voxpopuli", "babel"]:
															lowercase						   =       wer_kwargs.pop('concatenate_texts'      ,  _lowercase    )
															return wer_and_cer(_lowercase      ,  _lowercase      ,  _lowercase      ,  self.config_name    )
										else:
															raise KeyError(F"""You should supply a configuration name selected in {_CONFIG_NAMES}"""    )







"""simple docstring"""







import os
import warnings
from pathlib import Path
from typing import Optional, Union

from .dynamic_module_utils import custom_object_save
from .tokenization_utils_base import PreTrainedTokenizerBase
from .utils import PushToHubMixin, copy_func, direct_transformers_import, logging


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

# Dynamically import the Transformers module to grab the attribute classes of the processor form their names.
UpperCamelCase_							:							Optional[Any]				 =		direct_transformers_import(Path(__file__).parent)


UpperCamelCase_							:							Optional[int]				 =		{
    """AutoTokenizer""": """PreTrainedTokenizerBase""",
    """AutoFeatureExtractor""": """FeatureExtractionMixin""",
    """AutoImageProcessor""": """ImageProcessingMixin""",
}


class       _lowercase		( __lowerCamelCase	):
				lowerCamelCase__							=							['feature_extractor', 'tokenizer']
				# Names need to be attr_class for attr in attributes
				lowerCamelCase__							=							None
				lowerCamelCase__							=							None
				lowerCamelCase__							=							None

				def __init__(  self							:     Any							,     *_lowercase							:     Optional[int]							,     **_lowercase							:     int  ):


										'''simple docstring'''
										# Sanitize args and kwargs
										for key in kwargs:
																if key not in self.attributes:
																						raise TypeError(f'Unexpected keyword argument {key}.'  )
										for arg, attribute_name in zip(_lowercase							,     self.attributes  ):
																if attribute_name in kwargs:
																						raise TypeError(f'Got multiple values for argument {attribute_name}.'  )
																else:
																						UpperCAmelCase__       						=		arg

										if len(_lowercase  ) != len(self.attributes  ):
																raise ValueError(
																    f'This processor requires {len(self.attributes  )} arguments: {", ".join(self.attributes  )}. Got '
																    f'{len(_lowercase  )} arguments instead.'  )

										# Check each arg is of the proper class (this will also catch a user initializing in the wrong order)
										for attribute_name, arg in kwargs.items():
																UpperCAmelCase__       						=		getattr(self							,     f'{attribute_name}_class'  )
																# Nothing is ever going to be an instance of "AutoXxx", in that case we check the base class.
																UpperCAmelCase__       						=		AUTO_TO_BASE_CLASS_MAPPING.get(_lowercase							,     _lowercase  )
																if isinstance(_lowercase							,     _lowercase  ):
																						UpperCAmelCase__       						=		tuple(getattr(_lowercase							,     _lowercase  ) for n in class_name if n is not None  )
																else:
																						UpperCAmelCase__       						=		getattr(_lowercase							,     _lowercase  )

																if not isinstance(_lowercase							,     _lowercase  ):
																						raise ValueError(
																						    f'Received a {type(_lowercase  ).__name__} for argument {attribute_name}, but a {class_name} was expected.'  )

																setattr(self							,     _lowercase							,     _lowercase  )

				def __repr__(  self							:     Tuple  ):


										'''simple docstring'''
										UpperCAmelCase__       						=		[f'- {name}: {repr(getattr(self							,     _lowercase  )  )}' for name in self.attributes]
										UpperCAmelCase__       						=		"""\n""".join(_lowercase  )
										return f'{self.__class__.__name__}:\n{attributes_repr}'

				def 							A			(  self							:     Tuple							,     _lowercase							:     Dict							,     _lowercase							:     bool = False							,     **_lowercase							:     List[str]  ):


										'''simple docstring'''
										os.makedirs(_lowercase							,     exist_ok=_lowercase  )

										if push_to_hub:
																UpperCAmelCase__       						=		kwargs.pop("""commit_message"""							,     _lowercase  )
																UpperCAmelCase__       						=		kwargs.pop("""repo_id"""							,     save_directory.split(os.path.sep  )[-1]  )
																UpperCAmelCase__       						=		self._create_repo(_lowercase							,     **_lowercase  )
																UpperCAmelCase__       						=		self._get_files_timestamps(_lowercase  )
										# If we have a custom config, we copy the file defining it in the folder and set the attributes so it can be
										# loaded from the Hub.
										if self._auto_class is not None:
																UpperCAmelCase__       						=		[getattr(self							,     _lowercase  ) for attribute_name in self.attributes]
																UpperCAmelCase__       						=		[(a.init_kwargs if isinstance(_lowercase							,     _lowercase  ) else a) for a in attrs]
																custom_object_save(self							,     _lowercase							,     config=_lowercase  )

										for attribute_name in self.attributes:
																UpperCAmelCase__       						=		getattr(self							,     _lowercase  )
																# Include the processor class in the attribute config so this processor can then be reloaded with the
																# `AutoProcessor` API.
																if hasattr(_lowercase							,     """_set_processor_class"""  ):
																						attribute._set_processor_class(self.__class__.__name__  )
																attribute.save_pretrained(_lowercase  )

										if self._auto_class is not None:
																# We added an attribute to the init_kwargs of the tokenizers, which needs to be cleaned up.
																for attribute_name in self.attributes:
																						UpperCAmelCase__       						=		getattr(self							,     _lowercase  )
																						if isinstance(_lowercase							,     _lowercase  ):
																												del attribute.init_kwargs["auto_map"]

										if push_to_hub:
																self._upload_modified_files(
																    _lowercase							,     _lowercase							,     _lowercase							,     commit_message=_lowercase							,     token=kwargs.get("""use_auth_token"""  )							,     )

				@classmethod
				def 							A			(  cls							:     Dict							,     _lowercase							:     Union[str, os.PathLike]							,     _lowercase							:     Optional[Union[str, os.PathLike]] = None							,     _lowercase							:     bool = False							,     _lowercase							:     bool = False							,     _lowercase							:     Optional[Union[str, bool]] = None							,     _lowercase							:     str = "main"							,     **_lowercase							:     Dict							,     ):


										'''simple docstring'''
										UpperCAmelCase__       						=		cache_dir
										UpperCAmelCase__       						=		force_download
										UpperCAmelCase__       						=		local_files_only
										UpperCAmelCase__       						=		revision

										UpperCAmelCase__       						=		kwargs.pop("""use_auth_token"""							,     _lowercase  )
										if use_auth_token is not None:
																warnings.warn(
																    """The `use_auth_token` argument is deprecated and will be removed in v5 of Transformers."""							,     _lowercase  )
																if token is not None:
																						raise ValueError(
																						    """`token` and `use_auth_token` are both specified. Please set only the argument `token`."""  )
																UpperCAmelCase__       						=		use_auth_token

										if token is not None:
																# change to `token` in a follow-up PR
																UpperCAmelCase__       						=		token

										UpperCAmelCase__       						=		cls._get_arguments_from_pretrained(_lowercase							,     **_lowercase  )
										return cls(*_lowercase  )

				@classmethod
				def 							A			(  cls							:     List[Any]							,     _lowercase							:     Dict="AutoProcessor"  ):


										'''simple docstring'''
										if not isinstance(_lowercase							,     _lowercase  ):
																UpperCAmelCase__       						=		auto_class.__name__

										import transformers.models.auto as auto_module

										if not hasattr(_lowercase							,     _lowercase  ):
																raise ValueError(f'{auto_class} is not a valid auto class.'  )

										UpperCAmelCase__       						=		auto_class

				@classmethod
				def 							A			(  cls							:     Any							,     _lowercase							:     Tuple							,     **_lowercase							:     List[Any]  ):


										'''simple docstring'''
										UpperCAmelCase__       						=		[]
										for attribute_name in cls.attributes:
																UpperCAmelCase__       						=		getattr(cls							,     f'{attribute_name}_class'  )
																if isinstance(_lowercase							,     _lowercase  ):
																						UpperCAmelCase__       						=		tuple(getattr(_lowercase							,     _lowercase  ) if n is not None else None for n in class_name  )
																						UpperCAmelCase__       						=		kwargs.get("""use_fast"""							,     _lowercase  )
																						if use_fast and classes[1] is not None:
																												UpperCAmelCase__       						=		classes[1]
																						else:
																												UpperCAmelCase__       						=		classes[0]
																else:
																						UpperCAmelCase__       						=		getattr(_lowercase							,     _lowercase  )

																args.append(attribute_class.from_pretrained(_lowercase							,     **_lowercase  )  )
										return args

				@property
				def 							A			(  self							:     int  ):


										'''simple docstring'''
										UpperCAmelCase__       						=		getattr(self							,     self.attributes[0]  )
										return getattr(_lowercase							,     """model_input_names"""							,     _lowercase  )
UpperCamelCase_							:							List[Any]				 =		copy_func(ProcessorMixin.push_to_hub)
if ProcessorMixin.push_to_hub.__doc__ is not None:
						UpperCamelCase_							:							Dict				 =		ProcessorMixin.push_to_hub.__doc__.format(
						    object="""processor""", object_class="""AutoProcessor""", object_files="""processor files"""
						)

