






'''simple docstring'''







import re
import string

import numpy as np

import datasets


_A	:			Union[str, Any]         ='''
Returns the rate at which the input predicted strings exactly match their references, ignoring any strings input as part of the regexes_to_ignore list.
'''

_A	:			Union[str, Any]         ='''
Args:
    predictions: List of predicted texts.
    references: List of reference texts.
    regexes_to_ignore: List, defaults to None. Regex expressions of characters to
        ignore when calculating the exact matches. Note: these regexes are removed
        from the input data before the changes based on the options below (e.g. ignore_case,
        ignore_punctuation, ignore_numbers) are applied.
    ignore_case: Boolean, defaults to False. If true, turns everything
        to lowercase so that capitalization differences are ignored.
    ignore_punctuation: Boolean, defaults to False. If true, removes all punctuation before
        comparing predictions and references.
    ignore_numbers: Boolean, defaults to False. If true, removes all punctuation before
        comparing predictions and references.
Returns:
    exact_match: Dictionary containing exact_match rate. Possible values are between 0.0 and 100.0, inclusive.
Examples:
    >>> exact_match = datasets.load_metric("exact_match")
    >>> refs = ["the cat", "theater", "YELLING", "agent007"]
    >>> preds = ["cat?", "theater", "yelling", "agent"]
    >>> results = exact_match.compute(references=refs, predictions=preds)
    >>> print(round(results["exact_match"], 1))
    25.0

    >>> exact_match = datasets.load_metric("exact_match")
    >>> refs = ["the cat", "theater", "YELLING", "agent007"]
    >>> preds = ["cat?", "theater", "yelling", "agent"]
    >>> results = exact_match.compute(references=refs, predictions=preds, regexes_to_ignore=["the ", "yell"], ignore_case=True, ignore_punctuation=True)
    >>> print(round(results["exact_match"], 1))
    50.0


    >>> exact_match = datasets.load_metric("exact_match")
    >>> refs = ["the cat", "theater", "YELLING", "agent007"]
    >>> preds = ["cat?", "theater", "yelling", "agent"]
    >>> results = exact_match.compute(references=refs, predictions=preds, regexes_to_ignore=["the ", "yell", "YELL"], ignore_case=True, ignore_punctuation=True)
    >>> print(round(results["exact_match"], 1))
    75.0

    >>> exact_match = datasets.load_metric("exact_match")
    >>> refs = ["the cat", "theater", "YELLING", "agent007"]
    >>> preds = ["cat?", "theater", "yelling", "agent"]
    >>> results = exact_match.compute(references=refs, predictions=preds, regexes_to_ignore=["the ", "yell", "YELL"], ignore_case=True, ignore_punctuation=True, ignore_numbers=True)
    >>> print(round(results["exact_match"], 1))
    100.0

    >>> exact_match = datasets.load_metric("exact_match")
    >>> refs = ["The cat sat on the mat.", "Theaters are great.", "It\'s like comparing oranges and apples."]
    >>> preds = ["The cat sat on the mat?", "Theaters are great.", "It\'s like comparing apples and oranges."]
    >>> results = exact_match.compute(references=refs, predictions=preds)
    >>> print(round(results["exact_match"], 1))
    33.3

'''

_A	:			Dict         ='''
'''

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




							def 		lowerCamelCase_				(							self:				List[str]     ):
														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 		lowerCamelCase_				(							self:				str			,							UpperCamelCase__:				List[Any]			,							UpperCamelCase__:				int			,							UpperCamelCase__:				Any=None			,							UpperCamelCase__:				Any=False			,							UpperCamelCase__:				Optional[Any]=False			,							UpperCamelCase__:				List[Any]=False			,							):
														if regexes_to_ignore is not None:
																					for s in regexes_to_ignore:
																												lowerCamelCase__					:	Dict         =       np.array([re.sub(UpperCamelCase__			,							""""""			,							UpperCamelCase__     ) for x in predictions]     )
																												lowerCamelCase__					:	Union[str, Any]         =       np.array([re.sub(UpperCamelCase__			,							""""""			,							UpperCamelCase__     ) for x in references]     )
														else:
																					lowerCamelCase__					:	int         =       np.asarray(UpperCamelCase__     )
																					lowerCamelCase__					:	Tuple         =       np.asarray(UpperCamelCase__     )

														if ignore_case:
																					lowerCamelCase__					:	Union[str, Any]         =       np.char.lower(UpperCamelCase__     )
																					lowerCamelCase__					:	Tuple         =       np.char.lower(UpperCamelCase__     )

														if ignore_punctuation:
																					lowerCamelCase__					:	Dict         =       string.punctuation.maketrans(""""""			,							""""""			,							string.punctuation     )
																					lowerCamelCase__					:	Union[str, Any]         =       np.char.translate(UpperCamelCase__			,							table=UpperCamelCase__     )
																					lowerCamelCase__					:	Any         =       np.char.translate(UpperCamelCase__			,							table=UpperCamelCase__     )

														if ignore_numbers:
																					lowerCamelCase__					:	int         =       string.digits.maketrans(""""""			,							""""""			,							string.digits     )
																					lowerCamelCase__					:	Optional[int]         =       np.char.translate(UpperCamelCase__			,							table=UpperCamelCase__     )
																					lowerCamelCase__					:	Dict         =       np.char.translate(UpperCamelCase__			,							table=UpperCamelCase__     )

														lowerCamelCase__					:	Optional[Any]         =       predictions == references

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







import warnings

from ...utils import logging
from .image_processing_donut import DonutImageProcessor


__lowerCAmelCase		:				List[Any]       			=		logging.get_logger(__name__)




class     snake_case__							(_UpperCamelCase   ):
				"""simple docstring"""



				def __init__(      self				:     Union[str, Any]					,      *__lowerCamelCase				:     Optional[Any]					,      **__lowerCamelCase				:     Dict							)					->     None:
							warnings.warn(
							    "The class DonutFeatureExtractor is deprecated and will be removed in version 5 of Transformers. Please"
							    " use DonutImageProcessor instead."					,      __lowerCamelCase					,      )
							super().__init__(*__lowerCamelCase					,      **__lowerCamelCase							)






