

import json
from typing import List, Optional, Tuple

from tokenizers import pre_tokenizers, processors

from ...tokenization_utils_base import AddedToken, BatchEncoding
from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_bart import BartTokenizer


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


_UpperCAmelCase		:   Union[str, Any]										=       {'vocab_file': 'vocab.json', 'merges_file': 'merges.txt', 'tokenizer_file': 'tokenizer.json'}

# See all BART models at https://huggingface.co/models?filter=bart
_UpperCAmelCase		:   Optional[Any]										=       {
    'vocab_file': {
        'facebook/bart-base': 'https://huggingface.co/facebook/bart-base/resolve/main/vocab.json',
        'facebook/bart-large': 'https://huggingface.co/facebook/bart-large/resolve/main/vocab.json',
        'facebook/bart-large-mnli': 'https://huggingface.co/facebook/bart-large-mnli/resolve/main/vocab.json',
        'facebook/bart-large-cnn': 'https://huggingface.co/facebook/bart-large-cnn/resolve/main/vocab.json',
        'facebook/bart-large-xsum': 'https://huggingface.co/facebook/bart-large-xsum/resolve/main/vocab.json',
        'yjernite/bart_eli5': 'https://huggingface.co/yjernite/bart_eli5/resolve/main/vocab.json',
    },
    'merges_file': {
        'facebook/bart-base': 'https://huggingface.co/facebook/bart-base/resolve/main/merges.txt',
        'facebook/bart-large': 'https://huggingface.co/facebook/bart-large/resolve/main/merges.txt',
        'facebook/bart-large-mnli': 'https://huggingface.co/facebook/bart-large-mnli/resolve/main/merges.txt',
        'facebook/bart-large-cnn': 'https://huggingface.co/facebook/bart-large-cnn/resolve/main/merges.txt',
        'facebook/bart-large-xsum': 'https://huggingface.co/facebook/bart-large-xsum/resolve/main/merges.txt',
        'yjernite/bart_eli5': 'https://huggingface.co/yjernite/bart_eli5/resolve/main/merges.txt',
    },
    'tokenizer_file': {
        'facebook/bart-base': 'https://huggingface.co/facebook/bart-base/resolve/main/tokenizer.json',
        'facebook/bart-large': 'https://huggingface.co/facebook/bart-large/resolve/main/tokenizer.json',
        'facebook/bart-large-mnli': 'https://huggingface.co/facebook/bart-large-mnli/resolve/main/tokenizer.json',
        'facebook/bart-large-cnn': 'https://huggingface.co/facebook/bart-large-cnn/resolve/main/tokenizer.json',
        'facebook/bart-large-xsum': 'https://huggingface.co/facebook/bart-large-xsum/resolve/main/tokenizer.json',
        'yjernite/bart_eli5': 'https://huggingface.co/yjernite/bart_eli5/resolve/main/tokenizer.json',
    },
}

_UpperCAmelCase		:   Dict										=       {
    'facebook/bart-base': 1024,
    'facebook/bart-large': 1024,
    'facebook/bart-large-mnli': 1024,
    'facebook/bart-large-cnn': 1024,
    'facebook/bart-large-xsum': 1024,
    'yjernite/bart_eli5': 1024,
}







class  lowercase				(       lowerCAmelCase_			):
				__SCREAMING_SNAKE_CASE					: int       			=			VOCAB_FILES_NAMES
				__SCREAMING_SNAKE_CASE					: int       			=			PRETRAINED_VOCAB_FILES_MAP
				__SCREAMING_SNAKE_CASE					: int       			=			PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
				__SCREAMING_SNAKE_CASE					: Tuple       			=			['''input_ids''', '''attention_mask''']
				__SCREAMING_SNAKE_CASE					: Tuple       			=			BartTokenizer




				def __init__(					self      ,   snake_case=None      ,   snake_case=None      ,   snake_case=None      ,   snake_case="replace"      ,   snake_case="<s>"      ,   snake_case="</s>"      ,   snake_case="</s>"      ,   snake_case="<s>"      ,   snake_case="<unk>"      ,   snake_case="<pad>"      ,   snake_case="<mask>"      ,   snake_case=False      ,   snake_case=True      ,   **snake_case      ,   ):
											super().__init__(
											    __a      ,   __a      ,   tokenizer_file=__a      ,   errors=__a      ,   bos_token=__a      ,   eos_token=__a      ,   sep_token=__a      ,   cls_token=__a      ,   unk_token=__a      ,   pad_token=__a      ,   mask_token=__a      ,   add_prefix_space=__a      ,   trim_offsets=__a      ,   **__a      ,   )

											snake_case_							=    json.loads(self.backend_tokenizer.pre_tokenizer.__getstate__()       )
											if pre_tok_state.get('add_prefix_space'      ,   __a       ) != add_prefix_space:
																		snake_case_							=    getattr(__a      ,   pre_tok_state.pop('type'       )       )
																		snake_case_							=    add_prefix_space
																		snake_case_							=    pre_tok_class(**__a       )

											snake_case_							=    add_prefix_space

											# the pre_tokenizer is already updated in the GPT2TokenizerFast `__init__`
											snake_case_							=    'post_processor'
											snake_case_							=    getattr(self.backend_tokenizer      ,   __a      ,   __a       )
											if tokenizer_component_instance:
																		snake_case_							=    json.loads(tokenizer_component_instance.__getstate__()       )

																		# The lists 'sep' and 'cls' must be cased in tuples for the object `post_processor_class`
																		if "sep" in state:
																									snake_case_							=    tuple(state['sep']       )
																		if "cls" in state:
																									snake_case_							=    tuple(state['cls']       )

																		snake_case_							=    False

																		if state.get('add_prefix_space'      ,   __a       ) != add_prefix_space:
																									snake_case_							=    add_prefix_space
																									snake_case_							=    True

																		if state.get('trim_offsets'      ,   __a       ) != trim_offsets:
																									snake_case_							=    trim_offsets
																									snake_case_							=    True

																		if changes_to_apply:
																									snake_case_							=    getattr(__a      ,   state.pop('type'       )       )
																									snake_case_							=    component_class(**__a       )
																									setattr(self.backend_tokenizer      ,   __a      ,   __a       )




				@property
				def     a							(					self       ):





											if self._mask_token is None:
																		if self.verbose:
																									logger.error('Using mask_token, but it is not set yet.'       )
																		return None
											return str(self._mask_token       )




				@mask_token.setter
				def     a							(					self      ,   snake_case       ):
											snake_case_							=    AddedToken(__a      ,   lstrip=__a      ,   rstrip=__a       ) if isinstance(__a      ,   __a       ) else value
											snake_case_							=    value




				def     a							(					self      ,   *snake_case      ,   **snake_case       ):
											snake_case_							=    kwargs.get('is_split_into_words'      ,   __a       )

											if is_split_into_words and not self.add_prefix_space:
																		raise ValueError(
																		    F'''You need to instantiate {self.__class__.__name__} with add_prefix_space=True '''
																		    'to use it with pretokenized inputs.'       )

											return super()._batch_encode_plus(*__a      ,   **__a       )




				def     a							(					self      ,   *snake_case      ,   **snake_case       ):
											snake_case_							=    kwargs.get('is_split_into_words'      ,   __a       )

											if is_split_into_words and not self.add_prefix_space:
																		raise ValueError(
																		    F'''You need to instantiate {self.__class__.__name__} with add_prefix_space=True '''
																		    'to use it with pretokenized inputs.'       )

											return super()._encode_plus(*__a      ,   **__a       )




				def     a							(					self      ,   snake_case      ,   snake_case = None       ):
											snake_case_							=    self._tokenizer.model.save(__a      ,   name=__a       )
											return tuple(__a       )




				def     a							(					self      ,   snake_case      ,   snake_case=None       ):
											snake_case_							=    [self.bos_token_id] + token_ids_a + [self.eos_token_id]
											if token_ids_a is None:
																		return output

											return output + [self.eos_token_id] + token_ids_a + [self.eos_token_id]




				def     a							(					self      ,   snake_case      ,   snake_case = None       ):
											snake_case_							=    [self.sep_token_id]
											snake_case_							=    [self.cls_token_id]

											if token_ids_a is None:
																		return len(cls + token_ids_a + sep       ) * [0]
											return len(cls + token_ids_a + sep + sep + token_ids_a + sep       ) * [0]








'''simple docstring'''



import re
import string

import numpy as np

import datasets


__lowercase	:						Tuple       =	'\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'

__lowercase	:						List[str]       =	'\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'

__lowercase	:						Any       =	'\n'





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




	def       __UpperCAmelCase							(   self							):

						'''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       __UpperCAmelCase							(   self						,				__a						,				__a						,				__a=None						,				__a=False						,				__a=False						,				__a=False						,				):

						'''simple docstring'''





						if regexes_to_ignore is not None:
											for s in regexes_to_ignore:
																__a			:       Tuple					    =  np.array([re.sub(__a						,				''						,				__a							) for x in predictions]							)
																__a			:       List[Any]					    =  np.array([re.sub(__a						,				''						,				__a							) for x in references]							)
						else:
											__a			:       int					    =  np.asarray(__a							)
											__a			:       str					    =  np.asarray(__a							)

						if ignore_case:
											__a			:       Dict					    =  np.char.lower(__a							)
											__a			:       List[str]					    =  np.char.lower(__a							)

						if ignore_punctuation:
											__a			:       Dict					    =  string.punctuation.maketrans(''						,				''						,				string.punctuation							)
											__a			:       Tuple					    =  np.char.translate(__a						,				table=__a							)
											__a			:       Dict					    =  np.char.translate(__a						,				table=__a							)

						if ignore_numbers:
											__a			:       Optional[int]					    =  string.digits.maketrans(''						,				''						,				string.digits							)
											__a			:       Tuple					    =  np.char.translate(__a						,				table=__a							)
											__a			:       Optional[int]					    =  np.char.translate(__a						,				table=__a							)

						__a			:       Any					    =  predictions == references

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



