
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        = '\\n'

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

try:
						from jiwer import transforms as tr

						__a        = True
except ImportError:
						__a        = 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  :      Union[str, Any]	,							SCREAMING_SNAKE_CASE_  :      str = " "	)	->					Any:
											lowercase_					  = sentence_delimiter
							def 						_lowercase  (	self  :      Optional[Any]	,							SCREAMING_SNAKE_CASE_  :      str	)	->					Union[str, Any]:
											return list(SCREAMING_SNAKE_CASE_	)




							def 						_lowercase  (	self  :      List[str]	,							SCREAMING_SNAKE_CASE_  :      List[str]	)	->					List[str]:
											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

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




def     a						(							snake_case__: List[Any]						,       snake_case__: List[str] ):


				'''simple docstring'''
				return float((preds == labels).mean() )




def     a						(							snake_case__: Optional[int]						,       snake_case__: Optional[Any] ):


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




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


				'''simple docstring'''
				# xtreme-s can only have one label
				lowercase_					  = [[label] for label in labels]
				lowercase_					  = 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"`.''' )

				lowercase_					  = 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''' )
				lowercase_					  = [[refs[i] for refs in labels] for i in range(snake_case__ )]
				lowercase_					  = 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     a						(							snake_case__: Union[str, Any]						,       snake_case__: List[str]						,       snake_case__: int						,       snake_case__: List[Any] ):


				'''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(snake_case__						,       snake_case__ )['''wer''']

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



	"""simple docstring"""




	def 						_lowercase  (	self  :      Dict	)	->					Optional[Any]:
					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 						_lowercase  (	self  :      Union[str, Any]	,							SCREAMING_SNAKE_CASE_  :      Tuple	,							SCREAMING_SNAKE_CASE_  :      Union[str, Any]	,							SCREAMING_SNAKE_CASE_  :      Any=None	,							SCREAMING_SNAKE_CASE_  :      Dict=None	)	->					Optional[int]:
					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}'''	)






import warnings
from typing import List, Optional, Union

from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding, PaddingStrategy, PreTokenizedInput, TextInput, TruncationStrategy
from ...utils import TensorType
class 			lowercase__(    UpperCAmelCase							):



	"""simple docstring"""




	a      :Any   					=     ['image_processor', 'tokenizer']
	a      :Tuple   					=     'LayoutLMv2ImageProcessor'
	a      :List[Any]   					=     ('LayoutLMv2Tokenizer', 'LayoutLMv2TokenizerFast')
	def __init__(	self  :      Tuple	,							SCREAMING_SNAKE_CASE_  :      Any=None	,							SCREAMING_SNAKE_CASE_  :      Any=None	,							**SCREAMING_SNAKE_CASE_  :      List[str]	)	->					Optional[Any]:
					lowercase_					  = None
					if "feature_extractor" in kwargs:
									warnings.warn(
									    '''The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`'''
									    ''' instead.'''	,							SCREAMING_SNAKE_CASE_	,							)
									lowercase_					  = kwargs.pop('''feature_extractor'''	)

					lowercase_					  = 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__(SCREAMING_SNAKE_CASE_	,							SCREAMING_SNAKE_CASE_	)
	def __call__(	self  :      Any	,							SCREAMING_SNAKE_CASE_  :      int	,							SCREAMING_SNAKE_CASE_  :      Union[TextInput, PreTokenizedInput, List[TextInput], List[PreTokenizedInput]] = None	,							SCREAMING_SNAKE_CASE_  :      Optional[Union[PreTokenizedInput, List[PreTokenizedInput]]] = None	,							SCREAMING_SNAKE_CASE_  :      Union[List[List[int]], List[List[List[int]]]] = None	,							SCREAMING_SNAKE_CASE_  :      Optional[Union[List[int], List[List[int]]]] = None	,							SCREAMING_SNAKE_CASE_  :      bool = True	,							SCREAMING_SNAKE_CASE_  :      Union[bool, str, PaddingStrategy] = False	,							SCREAMING_SNAKE_CASE_  :      Union[bool, str, TruncationStrategy] = False	,							SCREAMING_SNAKE_CASE_  :      Optional[int] = None	,							SCREAMING_SNAKE_CASE_  :      int = 0	,							SCREAMING_SNAKE_CASE_  :      Optional[int] = None	,							SCREAMING_SNAKE_CASE_  :      Optional[bool] = None	,							SCREAMING_SNAKE_CASE_  :      Optional[bool] = None	,							SCREAMING_SNAKE_CASE_  :      bool = False	,							SCREAMING_SNAKE_CASE_  :      bool = False	,							SCREAMING_SNAKE_CASE_  :      bool = False	,							SCREAMING_SNAKE_CASE_  :      bool = False	,							SCREAMING_SNAKE_CASE_  :      bool = True	,							SCREAMING_SNAKE_CASE_  :      Optional[Union[str, TensorType]] = None	,							**SCREAMING_SNAKE_CASE_  :      List[Any]	,							)	->					BatchEncoding:
					# verify input
					if self.image_processor.apply_ocr and (boxes is not None):
									raise ValueError(
									    '''You cannot provide bounding boxes if you initialized the image processor with apply_ocr set to True.'''	)

					if self.image_processor.apply_ocr and (word_labels is not None):
									raise ValueError(
									    '''You cannot provide word labels if you initialized the image processor with apply_ocr set to True.'''	)

					if return_overflowing_tokens is True and return_offsets_mapping is False:
									raise ValueError('''You cannot return overflowing tokens without returning the offsets mapping.'''	)

					# first, apply the image processor
					lowercase_					  = self.image_processor(images=SCREAMING_SNAKE_CASE_	,							return_tensors=SCREAMING_SNAKE_CASE_	)

					# second, apply the tokenizer
					if text is not None and self.image_processor.apply_ocr and text_pair is None:
									if isinstance(SCREAMING_SNAKE_CASE_	,							SCREAMING_SNAKE_CASE_	):
													lowercase_					  = [text]  # add batch dimension (as the image processor always adds a batch dimension)
									lowercase_					  = features['''words''']

					lowercase_					  = self.tokenizer(
					    text=text if text is not None else features['''words''']	,							text_pair=text_pair if text_pair is not None else None	,							boxes=boxes if boxes is not None else features['''boxes''']	,							word_labels=SCREAMING_SNAKE_CASE_	,							add_special_tokens=SCREAMING_SNAKE_CASE_	,							padding=SCREAMING_SNAKE_CASE_	,							truncation=SCREAMING_SNAKE_CASE_	,							max_length=SCREAMING_SNAKE_CASE_	,							stride=SCREAMING_SNAKE_CASE_	,							pad_to_multiple_of=SCREAMING_SNAKE_CASE_	,							return_token_type_ids=SCREAMING_SNAKE_CASE_	,							return_attention_mask=SCREAMING_SNAKE_CASE_	,							return_overflowing_tokens=SCREAMING_SNAKE_CASE_	,							return_special_tokens_mask=SCREAMING_SNAKE_CASE_	,							return_offsets_mapping=SCREAMING_SNAKE_CASE_	,							return_length=SCREAMING_SNAKE_CASE_	,							verbose=SCREAMING_SNAKE_CASE_	,							return_tensors=SCREAMING_SNAKE_CASE_	,							**SCREAMING_SNAKE_CASE_	,							)

					# add pixel values
					lowercase_					  = features.pop('''pixel_values'''	)
					if return_overflowing_tokens is True:
									lowercase_					  = self.get_overflowing_images(SCREAMING_SNAKE_CASE_	,							encoded_inputs['''overflow_to_sample_mapping''']	)
					lowercase_					  = images

					return encoded_inputs
	def 						_lowercase  (	self  :      Tuple	,							SCREAMING_SNAKE_CASE_  :      str	,							SCREAMING_SNAKE_CASE_  :      Optional[int]	)	->					List[str]:
					# in case there's an overflow, ensure each `input_ids` sample is mapped to its corresponding image
					lowercase_					  = []
					for sample_idx in overflow_to_sample_mapping:
									images_with_overflow.append(images[sample_idx]	)

					if len(SCREAMING_SNAKE_CASE_	) != len(SCREAMING_SNAKE_CASE_	):
									raise ValueError(
									    '''Expected length of images to be the same as the length of `overflow_to_sample_mapping`, but got'''
									    f''' {len(SCREAMING_SNAKE_CASE_	)} and {len(SCREAMING_SNAKE_CASE_	)}'''	)

					return images_with_overflow
	def 						_lowercase  (	self  :      List[Any]	,							*SCREAMING_SNAKE_CASE_  :      Union[str, Any]	,							**SCREAMING_SNAKE_CASE_  :      Tuple	)	->					List[str]:
					return self.tokenizer.batch_decode(*SCREAMING_SNAKE_CASE_	,							**SCREAMING_SNAKE_CASE_	)
	def 						_lowercase  (	self  :      Optional[Any]	,							*SCREAMING_SNAKE_CASE_  :      Dict	,							**SCREAMING_SNAKE_CASE_  :      List[str]	)	->					List[Any]:
					return self.tokenizer.decode(*SCREAMING_SNAKE_CASE_	,							**SCREAMING_SNAKE_CASE_	)
	@property
	def 						_lowercase  (	self  :      List[Any]	)	->					List[Any]:
					return ["input_ids", "bbox", "token_type_ids", "attention_mask", "image"]
	@property
	def 						_lowercase  (	self  :      Dict	)	->					str:
					warnings.warn(
					    '''`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead.'''	,							SCREAMING_SNAKE_CASE_	,							)
					return self.image_processor_class




	@property
	def 						_lowercase  (	self  :      int	)	->					List[str]:
					warnings.warn(
					    '''`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead.'''	,							SCREAMING_SNAKE_CASE_	,							)
					return self.image_processor




