
import json
import os
from typing import Optional, Tuple

from ...tokenization_utils import PreTrainedTokenizer
from ...utils import logging


__snake_case								=  logging.get_logger(__name__)

__snake_case								=  {'''vocab_file''': '''vocab.json'''}

__snake_case								=  {
    '''vocab_file''': {
        '''mgp-str''': '''https://huggingface.co/alibaba-damo/mgp-str-base/blob/main/vocab.json''',
    }
}

__snake_case								=  {'''mgp-str''': 27}




class 						lowercase__  (						_a  ):
	A__    :   Optional[Any]				       =VOCAB_FILES_NAMES
	A__    :   Optional[int]				       =PRETRAINED_VOCAB_FILES_MAP
	A__    :   Optional[int]				       =PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
	def __init__(			self							:   List[str]       ,   UpperCAmelCase_							:   str       ,   UpperCAmelCase_							:   int="[GO]"       ,   UpperCAmelCase_							:   Union[str, Any]="[GO]"       ,   UpperCAmelCase_							:   Tuple="[s]"       ,   UpperCAmelCase_							:   Any="[GO]"       ,   **UpperCAmelCase_							:   Optional[int]							):
						super().__init__(
						    unk_token=__lowerCamelCase       ,   bos_token=__lowerCamelCase       ,   eos_token=__lowerCamelCase       ,   pad_token=__lowerCamelCase       ,   **__lowerCamelCase       ,   )

						with open(__lowerCamelCase       ,   encoding='utf-8'							) as vocab_handle:
											SCREAMING_SNAKE_CASE__													= json.load(__lowerCamelCase							)
						SCREAMING_SNAKE_CASE__													= {v: k for k, v in self.vocab.items()}
	@property
	def      A_				(			self							:   Optional[Any]							):
						return len(self.vocab							)
	def      A_				(			self							:   int							):
						return dict(self.vocab       ,   **self.added_tokens_encoder							)
	def      A_				(			self							:   Union[str, Any]       ,   UpperCAmelCase_							:   Tuple							):
						SCREAMING_SNAKE_CASE__													= []
						for s in text:
											char_tokens.extend(__lowerCamelCase							)
						return char_tokens
	def      A_				(			self							:   int       ,   UpperCAmelCase_							:   List[Any]							):
						return self.vocab.get(__lowerCamelCase       ,   self.vocab.get(self.unk_token							)							)
	def      A_				(			self							:   str       ,   UpperCAmelCase_							:   List[Any]							):
						return self.decoder.get(__lowerCamelCase							)





	def      A_				(			self							:   Tuple       ,   UpperCAmelCase_							:   str       ,   UpperCAmelCase_							:   Optional[str] = None							):
						if not os.path.isdir(__lowerCamelCase							):
											logger.error('Vocabulary path ({}) should be a directory'.format(__lowerCamelCase							)							)
											return
						SCREAMING_SNAKE_CASE__													= os.path.join(
						    __lowerCamelCase       ,   (filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['vocab_file']							)

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

						return (vocab_file,)













import re
import string

import numpy as np

import datasets


UpperCAmelCase_ :						Dict      =      '''
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.
'''

UpperCAmelCase_ :						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

'''

UpperCAmelCase_ :						Tuple      =      '''
'''

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





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

		if ignore_case:
			UpperCamelCase     :Tuple          =	np.char.lower(__lowerCamelCase	)
			UpperCamelCase     :Any          =	np.char.lower(__lowerCamelCase	)

		if ignore_punctuation:
			UpperCamelCase     :Optional[int]          =	string.punctuation.maketrans("""""" ,  """""" ,  string.punctuation	)
			UpperCamelCase     :Optional[Any]          =	np.char.translate(__lowerCamelCase ,  table=__lowerCamelCase	)
			UpperCamelCase     :List[str]          =	np.char.translate(__lowerCamelCase ,  table=__lowerCamelCase	)

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

		UpperCamelCase     :int          =	predictions == references

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