






'''simple docstring'''

import numpy as np

from transformers import BatchFeature
from transformers.testing_utils import require_tf, require_torch

from .test_feature_extraction_common import FeatureExtractionSavingTestMixin






class     a_						(      lowerCamelCase    ):
  # to overwrite at feature extractactor specific tests
  lowercase							=				None
  lowercase							=				None

  @property
  def   A__						(				self				)  ->				Dict:



        """simple docstring"""






        return self.feat_extract_tester.prepare_feat_extract_dict()

  def   A__						(				self				)  ->				Tuple:



        """simple docstring"""






        UpperCamelCase      = self.feature_extraction_class(**self.feat_extract_dict				)
        self.assertTrue(hasattr(_SCREAMING_SNAKE_CASE      ,		"""feature_size"""				)				)
        self.assertTrue(hasattr(_SCREAMING_SNAKE_CASE      ,		"""sampling_rate"""				)				)
        self.assertTrue(hasattr(_SCREAMING_SNAKE_CASE      ,		"""padding_value"""				)				)

  def   A__						(				self				)  ->				Dict:



        """simple docstring"""






        UpperCamelCase      = self.feat_extract_tester.prepare_inputs_for_common()
        UpperCamelCase      = self.feature_extraction_class(**self.feat_extract_dict				)
        UpperCamelCase      = feat_extract.model_input_names[0]

        UpperCamelCase      = BatchFeature({input_name: speech_inputs}				)

        self.assertTrue(all(len(_SCREAMING_SNAKE_CASE				) == len(_SCREAMING_SNAKE_CASE				) for x, y in zip(_SCREAMING_SNAKE_CASE      ,		processed_features[input_name]				)				)				)

        UpperCamelCase      = self.feat_extract_tester.prepare_inputs_for_common(equal_length=_SCREAMING_SNAKE_CASE				)
        UpperCamelCase      = BatchFeature({input_name: speech_inputs}      ,		tensor_type="""np"""				)

        UpperCamelCase      = processed_features[input_name]

        if len(batch_features_input.shape				) < 3:
              UpperCamelCase      = batch_features_input[:, :, None]

        self.assertTrue(
            batch_features_input.shape
            == (self.feat_extract_tester.batch_size, len(speech_inputs[0]				), self.feat_extract_tester.feature_size)				)

  @require_torch
  def   A__						(				self				)  ->				Optional[int]:



        """simple docstring"""






        UpperCamelCase      = self.feat_extract_tester.prepare_inputs_for_common(equal_length=_SCREAMING_SNAKE_CASE				)
        UpperCamelCase      = self.feature_extraction_class(**self.feat_extract_dict				)
        UpperCamelCase      = feat_extract.model_input_names[0]

        UpperCamelCase      = BatchFeature({input_name: speech_inputs}      ,		tensor_type="""pt"""				)

        UpperCamelCase      = processed_features[input_name]

        if len(batch_features_input.shape				) < 3:
              UpperCamelCase      = batch_features_input[:, :, None]

        self.assertTrue(
            batch_features_input.shape
            == (self.feat_extract_tester.batch_size, len(speech_inputs[0]				), self.feat_extract_tester.feature_size)				)

  @require_tf
  def   A__						(				self				)  ->				List[Any]:



        """simple docstring"""






        UpperCamelCase      = self.feat_extract_tester.prepare_inputs_for_common(equal_length=_SCREAMING_SNAKE_CASE				)
        UpperCamelCase      = self.feature_extraction_class(**self.feat_extract_dict				)
        UpperCamelCase      = feat_extract.model_input_names[0]

        UpperCamelCase      = BatchFeature({input_name: speech_inputs}      ,		tensor_type="""tf"""				)

        UpperCamelCase      = processed_features[input_name]

        if len(batch_features_input.shape				) < 3:
              UpperCamelCase      = batch_features_input[:, :, None]

        self.assertTrue(
            batch_features_input.shape
            == (self.feat_extract_tester.batch_size, len(speech_inputs[0]				), self.feat_extract_tester.feature_size)				)

  def   A__						(				self      ,		_SCREAMING_SNAKE_CASE=False				)  ->				int:



        """simple docstring"""






        def _inputs_have_equal_length(_SCREAMING_SNAKE_CASE				):
              UpperCamelCase      = len(input[0]				)
              for input_slice in input[1:]:
                    if len(_SCREAMING_SNAKE_CASE				) != length:
                          return False
              return True

        def _inputs_are_equal(_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE				):
              if len(_SCREAMING_SNAKE_CASE				) != len(_SCREAMING_SNAKE_CASE				):
                    return False

              for input_slice_a, input_slice_a in zip(_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE				):
                    if not np.allclose(np.asarray(_SCREAMING_SNAKE_CASE				)      ,		np.asarray(_SCREAMING_SNAKE_CASE				)      ,		atol=1e-3				):
                          return False
              return True

        UpperCamelCase      = self.feature_extraction_class(**self.feat_extract_dict				)
        UpperCamelCase      = self.feat_extract_tester.prepare_inputs_for_common(numpify=_SCREAMING_SNAKE_CASE				)
        UpperCamelCase      = feat_extract.model_input_names[0]

        UpperCamelCase      = BatchFeature({input_name: speech_inputs}				)

        UpperCamelCase      = self.feat_extract_tester.seq_length_diff
        UpperCamelCase      = self.feat_extract_tester.max_seq_length + pad_diff
        UpperCamelCase      = self.feat_extract_tester.min_seq_length
        UpperCamelCase      = self.feat_extract_tester.batch_size
        UpperCamelCase      = self.feat_extract_tester.feature_size

        # test padding for List[int] + numpy
        UpperCamelCase      = feat_extract.pad(_SCREAMING_SNAKE_CASE      ,		padding=_SCREAMING_SNAKE_CASE				)
        UpperCamelCase      = input_a[input_name]

        UpperCamelCase      = feat_extract.pad(_SCREAMING_SNAKE_CASE      ,		padding="""longest"""				)
        UpperCamelCase      = input_a[input_name]

        UpperCamelCase      = feat_extract.pad(_SCREAMING_SNAKE_CASE      ,		padding="""max_length"""      ,		max_length=len(speech_inputs[-1]				)				)
        UpperCamelCase      = input_a[input_name]

        UpperCamelCase      = feat_extract.pad(_SCREAMING_SNAKE_CASE      ,		padding="""longest"""      ,		return_tensors="""np"""				)
        UpperCamelCase      = input_a[input_name]

        # max_length parameter has to be provided when setting `padding="max_length"`
        with self.assertRaises(_SCREAMING_SNAKE_CASE				):
              feat_extract.pad(_SCREAMING_SNAKE_CASE      ,		padding="""max_length"""				)[input_name]

        UpperCamelCase      = feat_extract.pad(
            _SCREAMING_SNAKE_CASE      ,		padding="""max_length"""      ,		max_length=_SCREAMING_SNAKE_CASE      ,		return_tensors="""np"""				)
        UpperCamelCase      = input_a[input_name]

        self.assertFalse(_inputs_have_equal_length(_SCREAMING_SNAKE_CASE				)				)
        self.assertTrue(_inputs_have_equal_length(_SCREAMING_SNAKE_CASE				)				)
        self.assertTrue(_inputs_have_equal_length(_SCREAMING_SNAKE_CASE				)				)
        self.assertTrue(_inputs_are_equal(_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE				)				)
        self.assertTrue(len(input_a[0]				) == pad_min_length				)
        self.assertTrue(len(input_a[1]				) == pad_min_length + pad_diff				)
        self.assertTrue(input_a.shape[:2] == (batch_size, len(input_a[0]				))				)
        self.assertTrue(input_a.shape[:2] == (batch_size, pad_max_length)				)

        if feature_size > 1:
              self.assertTrue(input_a.shape[2] == input_a.shape[2] == feature_size				)

        # test padding for `pad_to_multiple_of` for List[int] + numpy
        UpperCamelCase      = feat_extract.pad(_SCREAMING_SNAKE_CASE      ,		pad_to_multiple_of=10				)
        UpperCamelCase      = input_a[input_name]

        UpperCamelCase      = feat_extract.pad(_SCREAMING_SNAKE_CASE      ,		padding="""longest"""      ,		pad_to_multiple_of=10				)
        UpperCamelCase      = input_a[input_name]

        UpperCamelCase      = feat_extract.pad(
            _SCREAMING_SNAKE_CASE      ,		padding="""max_length"""      ,		pad_to_multiple_of=10      ,		max_length=_SCREAMING_SNAKE_CASE				)
        UpperCamelCase      = input_a[input_name]

        UpperCamelCase      = feat_extract.pad(
            _SCREAMING_SNAKE_CASE      ,		padding="""max_length"""      ,		pad_to_multiple_of=10      ,		max_length=_SCREAMING_SNAKE_CASE      ,		return_tensors="""np"""      ,		)
        UpperCamelCase      = input_a[input_name]

        self.assertTrue(all(len(_SCREAMING_SNAKE_CASE				) % 10 == 0 for x in input_a				)				)
        self.assertTrue(_inputs_are_equal(_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE				)				)

        UpperCamelCase      = pad_max_length if pad_max_length % 10 == 0 else (pad_max_length // 10 + 1) * 10
        self.assertTrue(all(len(_SCREAMING_SNAKE_CASE				) == expected_mult_pad_length for x in input_a				)				)
        self.assertEqual(input_a.shape[:2]      ,		(batch_size, expected_mult_pad_length)				)

        if feature_size > 1:
              self.assertTrue(input_a.shape[2] == feature_size				)

        # Check padding value is correct
        UpperCamelCase      = (np.ones(self.feat_extract_tester.feature_size				) * feat_extract.padding_value).sum()
        self.assertTrue(
            abs(np.asarray(input_a[0]				)[pad_min_length:].sum() - padding_vector_sum * (pad_max_length - pad_min_length)				)
            < 1e-3				)
        self.assertTrue(
            abs(
                np.asarray(input_a[1]				)[pad_min_length + pad_diff :].sum()
                - padding_vector_sum * (pad_max_length - pad_min_length - pad_diff)				)
            < 1e-3				)
        self.assertTrue(
            abs(
                np.asarray(input_a[2]				)[pad_min_length + 2 * pad_diff :].sum()
                - padding_vector_sum * (pad_max_length - pad_min_length - 2 * pad_diff)				)
            < 1e-3				)
        self.assertTrue(
            abs(input_a[0, pad_min_length:].sum() - padding_vector_sum * (pad_max_length - pad_min_length)				) < 1e-3				)
        self.assertTrue(
            abs(input_a[0, pad_min_length:].sum() - padding_vector_sum * (expected_mult_pad_length - pad_min_length)				)
            < 1e-3				)

  def   A__						(				self      ,		_SCREAMING_SNAKE_CASE=False				)  ->				Dict:



        """simple docstring"""






        def _inputs_have_equal_length(_SCREAMING_SNAKE_CASE				):
              UpperCamelCase      = len(input[0]				)
              for input_slice in input[1:]:
                    if len(_SCREAMING_SNAKE_CASE				) != length:
                          return False
              return True

        def _inputs_are_equal(_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE				):
              if len(_SCREAMING_SNAKE_CASE				) != len(_SCREAMING_SNAKE_CASE				):
                    return False

              for input_slice_a, input_slice_a in zip(_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE				):
                    if not np.allclose(np.asarray(_SCREAMING_SNAKE_CASE				)      ,		np.asarray(_SCREAMING_SNAKE_CASE				)      ,		atol=1e-3				):
                          return False
              return True

        UpperCamelCase      = self.feature_extraction_class(**self.feat_extract_dict				)
        UpperCamelCase      = self.feat_extract_tester.prepare_inputs_for_common(numpify=_SCREAMING_SNAKE_CASE				)
        UpperCamelCase      = feat_extract.model_input_names[0]

        UpperCamelCase      = BatchFeature({input_name: speech_inputs}				)

        # truncate to smallest
        UpperCamelCase      = feat_extract.pad(
            _SCREAMING_SNAKE_CASE      ,		padding="""max_length"""      ,		max_length=len(speech_inputs[0]				)      ,		truncation=_SCREAMING_SNAKE_CASE				)
        UpperCamelCase      = input_a[input_name]

        UpperCamelCase      = feat_extract.pad(_SCREAMING_SNAKE_CASE      ,		padding="""max_length"""      ,		max_length=len(speech_inputs[0]				)				)
        UpperCamelCase      = input_a[input_name]

        self.assertTrue(_inputs_have_equal_length(_SCREAMING_SNAKE_CASE				)				)
        self.assertFalse(_inputs_have_equal_length(_SCREAMING_SNAKE_CASE				)				)

        # truncate to smallest with np
        UpperCamelCase      = feat_extract.pad(
            _SCREAMING_SNAKE_CASE      ,		padding="""max_length"""      ,		max_length=len(speech_inputs[0]				)      ,		return_tensors="""np"""      ,		truncation=_SCREAMING_SNAKE_CASE      ,		)
        UpperCamelCase      = input_a[input_name]

        UpperCamelCase      = feat_extract.pad(
            _SCREAMING_SNAKE_CASE      ,		padding="""max_length"""      ,		max_length=len(speech_inputs[0]				)      ,		return_tensors="""np"""				)
        UpperCamelCase      = input_a[input_name]

        self.assertTrue(_inputs_have_equal_length(_SCREAMING_SNAKE_CASE				)				)
        self.assertTrue(input_a.shape[1] == len(speech_inputs[0]				)				)

        # since truncation forces padding to be smaller than longest input
        # function can't return `np.ndarray`, but has to return list
        self.assertFalse(_inputs_have_equal_length(_SCREAMING_SNAKE_CASE				)				)

        # truncate to middle
        UpperCamelCase      = feat_extract.pad(
            _SCREAMING_SNAKE_CASE      ,		padding="""max_length"""      ,		max_length=len(speech_inputs[1]				)      ,		truncation=_SCREAMING_SNAKE_CASE      ,		return_tensors="""np"""      ,		)
        UpperCamelCase      = input_a[input_name]

        UpperCamelCase      = feat_extract.pad(
            _SCREAMING_SNAKE_CASE      ,		padding="""max_length"""      ,		max_length=len(speech_inputs[1]				)      ,		truncation=_SCREAMING_SNAKE_CASE				)
        UpperCamelCase      = input_a[input_name]

        UpperCamelCase      = feat_extract.pad(
            _SCREAMING_SNAKE_CASE      ,		padding="""max_length"""      ,		max_length=len(speech_inputs[1]				)      ,		return_tensors="""np"""				)
        UpperCamelCase      = input_a[input_name]

        self.assertTrue(input_a.shape[1] == len(speech_inputs[1]				)				)
        self.assertTrue(_inputs_have_equal_length(_SCREAMING_SNAKE_CASE				)				)
        self.assertTrue(_inputs_have_equal_length(_SCREAMING_SNAKE_CASE				)				)
        self.assertTrue(_inputs_are_equal(_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE				)				)

        # since truncation forces padding to be smaller than longest input
        # function can't return `np.ndarray`, but has to return list
        self.assertFalse(_inputs_have_equal_length(_SCREAMING_SNAKE_CASE				)				)
        self.assertTrue(len(input_a[-1]				) == len(speech_inputs[-1]				)				)

        # padding has to be max_length when setting `truncation=True`
        with self.assertRaises(_SCREAMING_SNAKE_CASE				):
              feat_extract.pad(_SCREAMING_SNAKE_CASE      ,		truncation=_SCREAMING_SNAKE_CASE				)[input_name]

        # padding has to be max_length when setting `truncation=True`
        with self.assertRaises(_SCREAMING_SNAKE_CASE				):
              feat_extract.pad(_SCREAMING_SNAKE_CASE      ,		padding="""longest"""      ,		truncation=_SCREAMING_SNAKE_CASE				)[input_name]

        # padding has to be max_length when setting `truncation=True`
        with self.assertRaises(_SCREAMING_SNAKE_CASE				):
              feat_extract.pad(_SCREAMING_SNAKE_CASE      ,		padding="""longest"""      ,		truncation=_SCREAMING_SNAKE_CASE				)[input_name]

        # max_length parameter has to be provided when setting `truncation=True` and padding="max_length"
        with self.assertRaises(_SCREAMING_SNAKE_CASE				):
              feat_extract.pad(_SCREAMING_SNAKE_CASE      ,		padding="""max_length"""      ,		truncation=_SCREAMING_SNAKE_CASE				)[input_name]

        # test truncation for `pad_to_multiple_of` for List[int] + numpy
        UpperCamelCase      = 12
        UpperCamelCase      = feat_extract.pad(
            _SCREAMING_SNAKE_CASE      ,		padding="""max_length"""      ,		max_length=len(speech_inputs[0]				)      ,		pad_to_multiple_of=_SCREAMING_SNAKE_CASE      ,		truncation=_SCREAMING_SNAKE_CASE      ,		)
        UpperCamelCase      = input_a[input_name]

        UpperCamelCase      = feat_extract.pad(
            _SCREAMING_SNAKE_CASE      ,		padding="""max_length"""      ,		max_length=len(speech_inputs[0]				)      ,		pad_to_multiple_of=_SCREAMING_SNAKE_CASE      ,		)
        UpperCamelCase      = input_a[input_name]

        # retrieve expected_length as multiple of pad_to_multiple_of
        UpperCamelCase      = len(speech_inputs[0]				)
        if expected_length % pad_to_multiple_of != 0:
              UpperCamelCase      = ((len(speech_inputs[0]				) // pad_to_multiple_of) + 1) * pad_to_multiple_of

        self.assertTrue(len(input_a[0]				) == expected_length				)
        self.assertTrue(_inputs_have_equal_length(_SCREAMING_SNAKE_CASE				)				)
        self.assertFalse(_inputs_have_equal_length(_SCREAMING_SNAKE_CASE				)				)

  def   A__						(				self				)  ->				Optional[int]:



        """simple docstring"""






        self._check_padding(numpify=_SCREAMING_SNAKE_CASE				)

  def   A__						(				self				)  ->				int:



        """simple docstring"""






        self._check_padding(numpify=_SCREAMING_SNAKE_CASE				)

  def   A__						(				self				)  ->				Optional[Any]:



        """simple docstring"""






        self._check_truncation(numpify=_SCREAMING_SNAKE_CASE				)

  def   A__						(				self				)  ->				Tuple:



        """simple docstring"""






        self._check_truncation(numpify=_SCREAMING_SNAKE_CASE				)

  @require_torch
  def   A__						(				self				)  ->				List[Any]:



        """simple docstring"""






        UpperCamelCase      = self.feature_extraction_class(**self.feat_extract_dict				)
        UpperCamelCase      = self.feat_extract_tester.prepare_inputs_for_common()
        UpperCamelCase      = feat_extract.model_input_names[0]

        UpperCamelCase      = BatchFeature({input_name: speech_inputs}				)

        UpperCamelCase      = feat_extract.pad(_SCREAMING_SNAKE_CASE      ,		padding="""longest"""      ,		return_tensors="""np"""				)[input_name]
        UpperCamelCase      = feat_extract.pad(_SCREAMING_SNAKE_CASE      ,		padding="""longest"""      ,		return_tensors="""pt"""				)[input_name]

        self.assertTrue(abs(input_np.astype(np.floataa				).sum() - input_pt.numpy().astype(np.floataa				).sum()				) < 1e-2				)

  @require_tf
  def   A__						(				self				)  ->				List[Any]:



        """simple docstring"""






        UpperCamelCase      = self.feature_extraction_class(**self.feat_extract_dict				)
        UpperCamelCase      = self.feat_extract_tester.prepare_inputs_for_common()
        UpperCamelCase      = feat_extract.model_input_names[0]

        UpperCamelCase      = BatchFeature({input_name: speech_inputs}				)

        UpperCamelCase      = feat_extract.pad(_SCREAMING_SNAKE_CASE      ,		padding="""longest"""      ,		return_tensors="""np"""				)[input_name]
        UpperCamelCase      = feat_extract.pad(_SCREAMING_SNAKE_CASE      ,		padding="""longest"""      ,		return_tensors="""tf"""				)[input_name]

        self.assertTrue(abs(input_np.astype(np.floataa				).sum() - input_tf.numpy().astype(np.floataa				).sum()				) < 1e-2				)

  def   A__						(				self				)  ->				List[Any]:



        """simple docstring"""






        UpperCamelCase      = self.feat_extract_dict
        UpperCamelCase      = True
        UpperCamelCase      = self.feature_extraction_class(**_SCREAMING_SNAKE_CASE				)
        UpperCamelCase      = self.feat_extract_tester.prepare_inputs_for_common()
        UpperCamelCase      = [len(_SCREAMING_SNAKE_CASE				) for x in speech_inputs]
        UpperCamelCase      = feat_extract.model_input_names[0]

        UpperCamelCase      = BatchFeature({input_name: speech_inputs}				)

        UpperCamelCase      = feat_extract.pad(_SCREAMING_SNAKE_CASE      ,		padding="""longest"""      ,		return_tensors="""np"""				)
        self.assertIn("""attention_mask"""      ,		_SCREAMING_SNAKE_CASE				)
        self.assertListEqual(list(processed.attention_mask.shape				)      ,		list(processed[input_name].shape[:2]				)				)
        self.assertListEqual(processed.attention_mask.sum(-1				).tolist()      ,		_SCREAMING_SNAKE_CASE				)


  def   A__						(				self				)  ->				List[str]:



        """simple docstring"""






        UpperCamelCase      = self.feat_extract_dict
        UpperCamelCase      = True
        UpperCamelCase      = self.feature_extraction_class(**_SCREAMING_SNAKE_CASE				)
        UpperCamelCase      = self.feat_extract_tester.prepare_inputs_for_common()
        UpperCamelCase      = [len(_SCREAMING_SNAKE_CASE				) for x in speech_inputs]
        UpperCamelCase      = feat_extract.model_input_names[0]

        UpperCamelCase      = BatchFeature({input_name: speech_inputs}				)
        UpperCamelCase      = min(_SCREAMING_SNAKE_CASE				)

        UpperCamelCase      = feat_extract.pad(
            _SCREAMING_SNAKE_CASE      ,		padding="""max_length"""      ,		max_length=_SCREAMING_SNAKE_CASE      ,		truncation=_SCREAMING_SNAKE_CASE      ,		return_tensors="""np"""				)
        self.assertIn("""attention_mask"""      ,		_SCREAMING_SNAKE_CASE				)
        self.assertListEqual(
            list(processed_pad.attention_mask.shape				)      ,		[processed_pad[input_name].shape[0], max_length]				)
        self.assertListEqual(
            processed_pad.attention_mask[:, :max_length].sum(-1				).tolist()      ,		[max_length for x in speech_inputs]				)








'''simple docstring'''

import re
import string

import numpy as np

import datasets


SCREAMING_SNAKE_CASE__     =       '\nReturns the rate at which the input predicted strings exactly match their references, ignoring any strings input as part of the regexes_to_ignore list.\n'

SCREAMING_SNAKE_CASE__     =       '\nArgs:\n    predictions: List of predicted texts.\n    references: List of reference texts.\n    regexes_to_ignore: List, defaults to None. Regex expressions of characters to\n        ignore when calculating the exact matches. Note: these regexes are removed\n        from the input data before the changes based on the options below (e.g. ignore_case,\n        ignore_punctuation, ignore_numbers) are applied.\n    ignore_case: Boolean, defaults to False. If true, turns everything\n        to lowercase so that capitalization differences are ignored.\n    ignore_punctuation: Boolean, defaults to False. If true, removes all punctuation before\n        comparing predictions and references.\n    ignore_numbers: Boolean, defaults to False. If true, removes all punctuation before\n        comparing predictions and references.\nReturns:\n    exact_match: Dictionary containing exact_match rate. Possible values are between 0.0 and 100.0, inclusive.\nExamples:\n    >>> exact_match = datasets.load_metric("exact_match")\n    >>> refs = ["the cat", "theater", "YELLING", "agent007"]\n    >>> preds = ["cat?", "theater", "yelling", "agent"]\n    >>> results = exact_match.compute(references=refs, predictions=preds)\n    >>> print(round(results["exact_match"], 1))\n    25.0\n\n    >>> exact_match = datasets.load_metric("exact_match")\n    >>> refs = ["the cat", "theater", "YELLING", "agent007"]\n    >>> preds = ["cat?", "theater", "yelling", "agent"]\n    >>> results = exact_match.compute(references=refs, predictions=preds, regexes_to_ignore=["the ", "yell"], ignore_case=True, ignore_punctuation=True)\n    >>> print(round(results["exact_match"], 1))\n    50.0\n\n\n    >>> exact_match = datasets.load_metric("exact_match")\n    >>> refs = ["the cat", "theater", "YELLING", "agent007"]\n    >>> preds = ["cat?", "theater", "yelling", "agent"]\n    >>> results = exact_match.compute(references=refs, predictions=preds, regexes_to_ignore=["the ", "yell", "YELL"], ignore_case=True, ignore_punctuation=True)\n    >>> print(round(results["exact_match"], 1))\n    75.0\n\n    >>> exact_match = datasets.load_metric("exact_match")\n    >>> refs = ["the cat", "theater", "YELLING", "agent007"]\n    >>> preds = ["cat?", "theater", "yelling", "agent"]\n    >>> results = exact_match.compute(references=refs, predictions=preds, regexes_to_ignore=["the ", "yell", "YELL"], ignore_case=True, ignore_punctuation=True, ignore_numbers=True)\n    >>> print(round(results["exact_match"], 1))\n    100.0\n\n    >>> exact_match = datasets.load_metric("exact_match")\n    >>> refs = ["The cat sat on the mat.", "Theaters are great.", "It\'s like comparing oranges and apples."]\n    >>> preds = ["The cat sat on the mat?", "Theaters are great.", "It\'s like comparing apples and oranges."]\n    >>> results = exact_match.compute(references=refs, predictions=preds)\n    >>> print(round(results["exact_match"], 1))\n    33.3\n\n'

SCREAMING_SNAKE_CASE__     =       '\n'






@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION     ,	_KWARGS_DESCRIPTION    )
class     a_						(      datasets.Metric    ):

  def   A__						(				self				)  ->				Optional[Any]:



        """simple docstring"""






        return datasets.MetricInfo(
            description=_DESCRIPTION      ,		citation=_CITATION      ,		inputs_description=_KWARGS_DESCRIPTION      ,		features=datasets.Features(
                {
                    """predictions""": datasets.Value("""string"""      ,		id="""sequence"""				),
                    """references""": datasets.Value("""string"""      ,		id="""sequence"""				),
                }				)      ,		reference_urls=[]      ,		)


  def   A__						(				self      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE=None      ,		_SCREAMING_SNAKE_CASE=False      ,		_SCREAMING_SNAKE_CASE=False      ,		_SCREAMING_SNAKE_CASE=False      ,		)  ->				List[Any]:



        """simple docstring"""






        if regexes_to_ignore is not None:
              for s in regexes_to_ignore:
                    UpperCamelCase      = np.array([re.sub(_SCREAMING_SNAKE_CASE      ,		""""""      ,		_SCREAMING_SNAKE_CASE				) for x in predictions]				)
                    UpperCamelCase      = np.array([re.sub(_SCREAMING_SNAKE_CASE      ,		""""""      ,		_SCREAMING_SNAKE_CASE				) for x in references]				)
        else:
              UpperCamelCase      = np.asarray(_SCREAMING_SNAKE_CASE				)
              UpperCamelCase      = np.asarray(_SCREAMING_SNAKE_CASE				)

        if ignore_case:
              UpperCamelCase      = np.char.lower(_SCREAMING_SNAKE_CASE				)
              UpperCamelCase      = np.char.lower(_SCREAMING_SNAKE_CASE				)

        if ignore_punctuation:
              UpperCamelCase      = string.punctuation.maketrans(""""""      ,		""""""      ,		string.punctuation				)
              UpperCamelCase      = np.char.translate(_SCREAMING_SNAKE_CASE      ,		table=_SCREAMING_SNAKE_CASE				)
              UpperCamelCase      = np.char.translate(_SCREAMING_SNAKE_CASE      ,		table=_SCREAMING_SNAKE_CASE				)

        if ignore_numbers:
              UpperCamelCase      = string.digits.maketrans(""""""      ,		""""""      ,		string.digits				)
              UpperCamelCase      = np.char.translate(_SCREAMING_SNAKE_CASE      ,		table=_SCREAMING_SNAKE_CASE				)
              UpperCamelCase      = np.char.translate(_SCREAMING_SNAKE_CASE      ,		table=_SCREAMING_SNAKE_CASE				)

        UpperCamelCase      = predictions == references

        return {"exact_match": np.mean(_SCREAMING_SNAKE_CASE				) * 100}
