



'''simple docstring'''

import re
import string
from collections import Counter

import sacrebleu
import sacremoses
from packaging import version

import datasets


a							   =				'\n@inproceedings{xu-etal-2016-optimizing,\n    title = {Optimizing Statistical Machine Translation for Text Simplification},\n    authors={Xu, Wei and Napoles, Courtney and Pavlick, Ellie and Chen, Quanze and Callison-Burch, Chris},\n    journal = {Transactions of the Association for Computational Linguistics},\n    volume = {4},\n    year={2016},\n    url = {https://www.aclweb.org/anthology/Q16-1029},\n    pages = {401--415\n},\n@inproceedings{post-2018-call,\n    title = "A Call for Clarity in Reporting {BLEU} Scores",\n    author = "Post, Matt",\n    booktitle = "Proceedings of the Third Conference on Machine Translation: Research Papers",\n    month = oct,\n    year = "2018",\n    address = "Belgium, Brussels",\n    publisher = "Association for Computational Linguistics",\n    url = "https://www.aclweb.org/anthology/W18-6319",\n    pages = "186--191",\n}\n'

a							   =				'\\nWIKI_SPLIT is the combination of three metrics SARI, EXACT and SACREBLEU\nIt can be used to evaluate the quality of machine-generated texts.\n'


a							   =				'\nCalculates sari score (between 0 and 100) given a list of source and predicted\nsentences, and a list of lists of reference sentences. It also computes the BLEU score as well as the exact match score.\nArgs:\n    sources: list of source sentences where each sentence should be a string.\n    predictions: list of predicted sentences where each sentence should be a string.\n    references: list of lists of reference sentences where each sentence should be a string.\nReturns:\n    sari: sari score\n    sacrebleu: sacrebleu score\n    exact: exact score\n\nExamples:\n    >>> sources=["About 95 species are currently accepted ."]\n    >>> predictions=["About 95 you now get in ."]\n    >>> references=[["About 95 species are currently known ."]]\n    >>> wiki_split = datasets.load_metric("wiki_split")\n    >>> results = wiki_split.compute(sources=sources, predictions=predictions, references=references)\n    >>> print(results)\n    {\'sari\': 21.805555555555557, \'sacrebleu\': 14.535768424205482, \'exact\': 0.0}\n'







def a_     (    __UpperCAmelCase					)				->					int:





			"""simple docstring"""







			def remove_articles(__UpperCAmelCase					):
						snake_case:    Any      							=re.compile(R'\b(a|an|the)\b'				,							re.UNICODE					)
						return re.sub(__UpperCAmelCase				,							' '				,							__UpperCAmelCase					)

			def white_space_fix(__UpperCAmelCase					):
						return " ".join(text.split()					)

			def remove_punc(__UpperCAmelCase					):
						snake_case:    Optional[Any]      							=set(string.punctuation					)
						return "".join(ch for ch in text if ch not in exclude					)

			def lower(__UpperCAmelCase					):
						return text.lower()

			return white_space_fix(remove_articles(remove_punc(lower(__UpperCAmelCase					)					)					)					)







def a_     (    __UpperCAmelCase				,							__UpperCAmelCase					)				->					Any:





			"""simple docstring"""







			return int(normalize_answer(__UpperCAmelCase					) == normalize_answer(__UpperCAmelCase					)					)







def a_     (    __UpperCAmelCase				,							__UpperCAmelCase					)				->					Optional[Any]:





			"""simple docstring"""







			snake_case:    Any      							=[any(compute_exact(__UpperCAmelCase				,							__UpperCAmelCase					) for ref in refs					) for pred, refs in zip(__UpperCAmelCase				,							__UpperCAmelCase					)]
			return (sum(__UpperCAmelCase					) / len(__UpperCAmelCase					)) * 1_00







def a_     (    __UpperCAmelCase				,							__UpperCAmelCase				,							__UpperCAmelCase				,							__UpperCAmelCase					)				->					str:





			"""simple docstring"""







			snake_case:    List[Any]      							=[rgram for rgrams in rgramslist for rgram in rgrams]
			snake_case:    Tuple      							=Counter(__UpperCAmelCase					)

			snake_case:    str      							=Counter(__UpperCAmelCase					)
			snake_case:    List[Any]      							=Counter()
			for sgram, scount in sgramcounter.items():
						snake_case:    Optional[Any]      							=scount * numref

			snake_case:    List[str]      							=Counter(__UpperCAmelCase					)
			snake_case:    str      							=Counter()
			for cgram, ccount in cgramcounter.items():
						snake_case:    int      							=ccount * numref

			# KEEP
			snake_case:    Any      							=sgramcounter_rep & cgramcounter_rep
			snake_case:    Optional[int]      							=keepgramcounter_rep & rgramcounter
			snake_case:    Optional[int]      							=sgramcounter_rep & rgramcounter

			snake_case:    Optional[Any]      							=0
			snake_case:    Dict      							=0
			for keepgram in keepgramcountergood_rep:
						keeptmpscorea += keepgramcountergood_rep[keepgram] / keepgramcounter_rep[keepgram]
						# Fix an alleged bug [2] in the keep score computation.
						# keeptmpscore2 += keepgramcountergood_rep[keepgram] / keepgramcounterall_rep[keepgram]
						keeptmpscorea += keepgramcountergood_rep[keepgram]
			# Define 0/0=1 instead of 0 to give higher scores for predictions that match
			#      a target exactly.
			snake_case:    List[str]      							=1
			snake_case:    Optional[int]      							=1
			if len(__UpperCAmelCase					) > 0:
						snake_case:    Optional[Any]      							=keeptmpscorea / len(__UpperCAmelCase					)
			if len(__UpperCAmelCase					) > 0:
						# Fix an alleged bug [2] in the keep score computation.
						# keepscore_recall = keeptmpscore2 / len(keepgramcounterall_rep)
						snake_case:    Optional[int]      							=keeptmpscorea / sum(keepgramcounterall_rep.values()					)
			snake_case:    int      							=0
			if keepscore_precision > 0 or keepscore_recall > 0:
						snake_case:    int      							=2 * keepscore_precision * keepscore_recall / (keepscore_precision + keepscore_recall)

			# DELETION
			snake_case:    List[str]      							=sgramcounter_rep - cgramcounter_rep
			snake_case:    int      							=delgramcounter_rep - rgramcounter
			snake_case:    Optional[int]      							=sgramcounter_rep - rgramcounter
			snake_case:    Tuple      							=0
			snake_case:    Dict      							=0
			for delgram in delgramcountergood_rep:
						deltmpscorea += delgramcountergood_rep[delgram] / delgramcounter_rep[delgram]
						deltmpscorea += delgramcountergood_rep[delgram] / delgramcounterall_rep[delgram]
			# Define 0/0=1 instead of 0 to give higher scores for predictions that match
			# a target exactly.
			snake_case:    List[Any]      							=1
			if len(__UpperCAmelCase					) > 0:
						snake_case:    List[Any]      							=deltmpscorea / len(__UpperCAmelCase					)

			# ADDITION
			snake_case:    int      							=set(__UpperCAmelCase					) - set(__UpperCAmelCase					)
			snake_case:    int      							=set(__UpperCAmelCase					) & set(__UpperCAmelCase					)
			snake_case:    str      							=set(__UpperCAmelCase					) - set(__UpperCAmelCase					)

			snake_case:    str      							=0
			for addgram in addgramcountergood:
						addtmpscore += 1

			# Define 0/0=1 instead of 0 to give higher scores for predictions that match
			# a target exactly.
			snake_case:    Tuple      							=1
			snake_case:    List[Any]      							=1
			if len(__UpperCAmelCase					) > 0:
						snake_case:    str      							=addtmpscore / len(__UpperCAmelCase					)
			if len(__UpperCAmelCase					) > 0:
						snake_case:    List[str]      							=addtmpscore / len(__UpperCAmelCase					)
			snake_case:    str      							=0
			if addscore_precision > 0 or addscore_recall > 0:
						snake_case:    List[Any]      							=2 * addscore_precision * addscore_recall / (addscore_precision + addscore_recall)

			return (keepscore, delscore_precision, addscore)







def a_     (    __UpperCAmelCase				,							__UpperCAmelCase				,							__UpperCAmelCase					)				->					int:





			"""simple docstring"""







			snake_case:    str      							=len(__UpperCAmelCase					)

			snake_case:    Optional[int]      							=ssent.split(' '					)
			snake_case:    str      							=csent.split(' '					)
			snake_case:    List[str]      							=[]
			snake_case:    Optional[int]      							=[]
			snake_case:    Optional[int]      							=[]
			snake_case:    str      							=[]
			snake_case:    str      							=[]
			snake_case:    List[Any]      							=[]

			snake_case:    Any      							=[]
			snake_case:    int      							=[]
			snake_case:    List[Any]      							=[]
			snake_case:    Optional[int]      							=[]
			for rsent in rsents:
						snake_case:    Optional[int]      							=rsent.split(' '					)
						snake_case:    Tuple      							=[]
						snake_case:    Dict      							=[]
						snake_case:    Optional[Any]      							=[]
						ragramslist.append(__UpperCAmelCase					)
						for i in range(0				,							len(__UpperCAmelCase					) - 1					):
									if i < len(__UpperCAmelCase					) - 1:
												snake_case:    str      							=ragrams[i] + ' ' + ragrams[i + 1]
												ragrams.append(__UpperCAmelCase					)
									if i < len(__UpperCAmelCase					) - 2:
												snake_case:    Dict      							=ragrams[i] + ' ' + ragrams[i + 1] + ' ' + ragrams[i + 2]
												ragrams.append(__UpperCAmelCase					)
									if i < len(__UpperCAmelCase					) - 3:
												snake_case:    Dict      							=ragrams[i] + ' ' + ragrams[i + 1] + ' ' + ragrams[i + 2] + ' ' + ragrams[i + 3]
												ragrams.append(__UpperCAmelCase					)
						ragramslist.append(__UpperCAmelCase					)
						ragramslist.append(__UpperCAmelCase					)
						ragramslist.append(__UpperCAmelCase					)

			for i in range(0				,							len(__UpperCAmelCase					) - 1					):
						if i < len(__UpperCAmelCase					) - 1:
									snake_case:    str      							=sagrams[i] + ' ' + sagrams[i + 1]
									sagrams.append(__UpperCAmelCase					)
						if i < len(__UpperCAmelCase					) - 2:
									snake_case:    str      							=sagrams[i] + ' ' + sagrams[i + 1] + ' ' + sagrams[i + 2]
									sagrams.append(__UpperCAmelCase					)
						if i < len(__UpperCAmelCase					) - 3:
									snake_case:    Optional[int]      							=sagrams[i] + ' ' + sagrams[i + 1] + ' ' + sagrams[i + 2] + ' ' + sagrams[i + 3]
									sagrams.append(__UpperCAmelCase					)

			for i in range(0				,							len(__UpperCAmelCase					) - 1					):
						if i < len(__UpperCAmelCase					) - 1:
									snake_case:    Tuple      							=cagrams[i] + ' ' + cagrams[i + 1]
									cagrams.append(__UpperCAmelCase					)
						if i < len(__UpperCAmelCase					) - 2:
									snake_case:    Tuple      							=cagrams[i] + ' ' + cagrams[i + 1] + ' ' + cagrams[i + 2]
									cagrams.append(__UpperCAmelCase					)
						if i < len(__UpperCAmelCase					) - 3:
									snake_case:    Optional[Any]      							=cagrams[i] + ' ' + cagrams[i + 1] + ' ' + cagrams[i + 2] + ' ' + cagrams[i + 3]
									cagrams.append(__UpperCAmelCase					)

			((snake_case)							,  (snake_case)							,  (snake_case)):    List[Any]      							=SARIngram(__UpperCAmelCase				,							__UpperCAmelCase				,							__UpperCAmelCase				,							__UpperCAmelCase					)
			((snake_case)							,  (snake_case)							,  (snake_case)):    Any      							=SARIngram(__UpperCAmelCase				,							__UpperCAmelCase				,							__UpperCAmelCase				,							__UpperCAmelCase					)
			((snake_case)							,  (snake_case)							,  (snake_case)):    Optional[Any]      							=SARIngram(__UpperCAmelCase				,							__UpperCAmelCase				,							__UpperCAmelCase				,							__UpperCAmelCase					)
			((snake_case)							,  (snake_case)							,  (snake_case)):    Dict      							=SARIngram(__UpperCAmelCase				,							__UpperCAmelCase				,							__UpperCAmelCase				,							__UpperCAmelCase					)
			snake_case:    Tuple      							=sum([keepascore, keepascore, keepascore, keepascore]					) / 4
			snake_case:    Any      							=sum([delascore, delascore, delascore, delascore]					) / 4
			snake_case:    int      							=sum([addascore, addascore, addascore, addascore]					) / 4
			snake_case:    Optional[Any]      							=(avgkeepscore + avgdelscore + avgaddscore) / 3
			return finalscore







def a_     (    __UpperCAmelCase				,							__UpperCAmelCase = True				,							__UpperCAmelCase = "13a"				,							__UpperCAmelCase = True					)				->					Dict:





			"""simple docstring"""







			if lowercase:
						snake_case:    Union[str, Any]      							=sentence.lower()

			if tokenizer in ["13a", "intl"]:
						if version.parse(sacrebleu.__version__					).major >= 2:
									snake_case:    str      							=sacrebleu.metrics.bleu._get_tokenizer(__UpperCAmelCase					)()(__UpperCAmelCase					)
						else:
									snake_case:    Dict      							=sacrebleu.TOKENIZERS[tokenizer]()(__UpperCAmelCase					)
			elif tokenizer == "moses":
						snake_case:    List[str]      							=sacremoses.MosesTokenizer().tokenize(__UpperCAmelCase				,							return_str=__UpperCAmelCase				,							escape=__UpperCAmelCase					)
			elif tokenizer == "penn":
						snake_case:    Optional[int]      							=sacremoses.MosesTokenizer().penn_tokenize(__UpperCAmelCase				,							return_str=__UpperCAmelCase					)
			else:
						snake_case:    List[Any]      							=sentence

			if not return_str:
						snake_case:    List[Any]      							=normalized_sent.split()

			return normalized_sent







def a_     (    __UpperCAmelCase				,							__UpperCAmelCase				,							__UpperCAmelCase					)				->					Optional[int]:





			"""simple docstring"""







			if not (len(__UpperCAmelCase					) == len(__UpperCAmelCase					) == len(__UpperCAmelCase					)):
						raise ValueError('Sources length must match predictions and references lengths.'					)
			snake_case:    str      							=0
			for src, pred, refs in zip(__UpperCAmelCase				,							__UpperCAmelCase				,							__UpperCAmelCase					):
						sari_score += SARIsent(normalize(__UpperCAmelCase					)				,							normalize(__UpperCAmelCase					)				,							[normalize(__UpperCAmelCase					) for sent in refs]					)
			snake_case:    int      							=sari_score / len(__UpperCAmelCase					)
			return 1_00 * sari_score







def a_     (    __UpperCAmelCase				,							__UpperCAmelCase				,							__UpperCAmelCase="exp"				,							__UpperCAmelCase=None				,							__UpperCAmelCase=False				,							__UpperCAmelCase=False				,							__UpperCAmelCase=False				,							)				->					Tuple:





			"""simple docstring"""







			snake_case:    int      							=len(references[0]					)
			if any(len(__UpperCAmelCase					) != references_per_prediction for refs in references					):
						raise ValueError('Sacrebleu requires the same number of references for each prediction'					)
			snake_case:    Any      							=[[refs[i] for refs in references] for i in range(__UpperCAmelCase					)]
			snake_case:    List[Any]      							=sacrebleu.corpus_bleu(
			    __UpperCAmelCase				,							__UpperCAmelCase				,							smooth_method=__UpperCAmelCase				,							smooth_value=__UpperCAmelCase				,							force=__UpperCAmelCase				,							lowercase=__UpperCAmelCase				,							use_effective_order=__UpperCAmelCase				,							)
			return output.score







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


							def    UpperCamelCase     (				self   :						str			)			->					Optional[int]:
										return datasets.MetricInfo(
										    description=_DESCRIPTION      ,						citation=_CITATION      ,						inputs_description=_KWARGS_DESCRIPTION      ,						features=datasets.Features(
										        {
										            'predictions': datasets.Value('string'      ,						id='sequence'			),
										            'references': datasets.Sequence(datasets.Value('string'      ,						id='sequence'			)      ,						id='references'			),
										        }			)      ,						codebase_urls=[
										        'https://github.com/huggingface/transformers/blob/master/src/transformers/data/metrics/squad_metrics.py',
										        'https://github.com/cocoxu/simplification/blob/master/SARI.py',
										        'https://github.com/tensorflow/tensor2tensor/blob/master/tensor2tensor/utils/sari_hook.py',
										        'https://github.com/mjpost/sacreBLEU',
										    ]      ,						reference_urls=[
										        'https://www.aclweb.org/anthology/Q16-1029.pdf',
										        'https://github.com/mjpost/sacreBLEU',
										        'https://en.wikipedia.org/wiki/BLEU',
										        'https://towardsdatascience.com/evaluating-text-output-in-nlp-bleu-at-your-own-risk-e8609665a213',
										    ]      ,						)




							def    UpperCamelCase     (				self   :						Union[str, Any]      ,						a_   :						Dict      ,						a_   :						int      ,						a_   :						int			)			->					List[str]:
										snake_case:    str      							={}
										result.update({'sari': compute_sari(sources=a_      ,						predictions=a_      ,						references=a_			)}			)
										result.update({'sacrebleu': compute_sacrebleu(predictions=a_      ,						references=a_			)}			)
										result.update({'exact': compute_em(predictions=a_      ,						references=a_			)}			)
										return result









'''simple docstring'''

import unittest

from transformers import SPIECE_UNDERLINE, XLNetTokenizer, XLNetTokenizerFast
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin


a							   =				get_tests_dir('fixtures/test_sentencepiece.model')






@require_sentencepiece
@require_tokenizers
class 						a_		(     snake_case    ,   unittest.TestCase    ):
							UpperCAmelCase			:		Tuple        =				XLNetTokenizer
							UpperCAmelCase			:		str        =				XLNetTokenizerFast
							UpperCAmelCase			:		str        =				True
							UpperCAmelCase			:		str        =				True


							def    UpperCamelCase     (				self   :						Optional[Any]			)			->					int:
										super().setUp()

										# We have a SentencePiece fixture for testing
										snake_case:    Tuple      							=XLNetTokenizer(a_      ,						keep_accents=a_			)
										tokenizer.sanitize_special_tokens()
										tokenizer.save_pretrained(self.tmpdirname			)


							def    UpperCamelCase     (				self   :						str			)			->					str:
										snake_case:    List[str]      							='<s>'
										snake_case:    Tuple      							=1

										self.assertEqual(self.get_tokenizer()._convert_token_to_id(a_			)      ,						a_			)
										self.assertEqual(self.get_tokenizer()._convert_id_to_token(a_			)      ,						a_			)


							def    UpperCamelCase     (				self   :						Any			)			->					int:
										snake_case:    str      							=list(self.get_tokenizer().get_vocab().keys()			)

										self.assertEqual(vocab_keys[0]      ,						'<unk>'			)
										self.assertEqual(vocab_keys[1]      ,						'<s>'			)
										self.assertEqual(vocab_keys[-1]      ,						'<eod>'			)
										self.assertEqual(len(a_			)      ,						1_0_0_6			)


							def    UpperCamelCase     (				self   :						Optional[Any]			)			->					List[Any]:
										self.assertEqual(self.get_tokenizer().vocab_size      ,						1_0_0_0			)


							def    UpperCamelCase     (				self   :						Union[str, Any]			)			->					Tuple:
										snake_case:    str      							=XLNetTokenizer(a_      ,						keep_accents=a_			)

										snake_case:    Dict      							=tokenizer.tokenize('This is a test'			)
										self.assertListEqual(a_      ,						['▁This', '▁is', '▁a', '▁t', 'est']			)

										self.assertListEqual(tokenizer.convert_tokens_to_ids(a_			)      ,						[2_8_5, 4_6, 1_0, 1_7_0, 3_8_2]			)

										snake_case:    List[str]      							=tokenizer.tokenize('I was born in 92000, and this is falsé.'			)
										self.assertListEqual(
										    a_      ,						[
										        SPIECE_UNDERLINE + 'I',
										        SPIECE_UNDERLINE + 'was',
										        SPIECE_UNDERLINE + 'b',
										        'or',
										        'n',
										        SPIECE_UNDERLINE + 'in',
										        SPIECE_UNDERLINE + '',
										        '9',
										        '2',
										        '0',
										        '0',
										        '0',
										        ',',
										        SPIECE_UNDERLINE + 'and',
										        SPIECE_UNDERLINE + 'this',
										        SPIECE_UNDERLINE + 'is',
										        SPIECE_UNDERLINE + 'f',
										        'al',
										        's',
										        'é',
										        '.',
										    ]      ,						)
										snake_case:    Optional[int]      							=tokenizer.convert_tokens_to_ids(a_			)
										self.assertListEqual(a_      ,						[8, 2_1, 8_4, 5_5, 2_4, 1_9, 7, 0, 6_0_2, 3_4_7, 3_4_7, 3_4_7, 3, 1_2, 6_6, 4_6, 7_2, 8_0, 6, 0, 4]			)

										snake_case:    List[str]      							=tokenizer.convert_ids_to_tokens(a_			)
										self.assertListEqual(
										    a_      ,						[
										        SPIECE_UNDERLINE + 'I',
										        SPIECE_UNDERLINE + 'was',
										        SPIECE_UNDERLINE + 'b',
										        'or',
										        'n',
										        SPIECE_UNDERLINE + 'in',
										        SPIECE_UNDERLINE + '',
										        '<unk>',
										        '2',
										        '0',
										        '0',
										        '0',
										        ',',
										        SPIECE_UNDERLINE + 'and',
										        SPIECE_UNDERLINE + 'this',
										        SPIECE_UNDERLINE + 'is',
										        SPIECE_UNDERLINE + 'f',
										        'al',
										        's',
										        '<unk>',
										        '.',
										    ]      ,						)


							def    UpperCamelCase     (				self   :						Dict			)			->					int:
										snake_case:    Tuple      							=XLNetTokenizer(a_      ,						do_lower_case=a_			)
										snake_case:    Optional[int]      							=tokenizer.tokenize('I was born in 92000, and this is falsé.'			)
										self.assertListEqual(
										    a_      ,						[
										        SPIECE_UNDERLINE + '',
										        'i',
										        SPIECE_UNDERLINE + 'was',
										        SPIECE_UNDERLINE + 'b',
										        'or',
										        'n',
										        SPIECE_UNDERLINE + 'in',
										        SPIECE_UNDERLINE + '',
										        '9',
										        '2',
										        '0',
										        '0',
										        '0',
										        ',',
										        SPIECE_UNDERLINE + 'and',
										        SPIECE_UNDERLINE + 'this',
										        SPIECE_UNDERLINE + 'is',
										        SPIECE_UNDERLINE + 'f',
										        'al',
										        'se',
										        '.',
										    ]      ,						)
										self.assertListEqual(tokenizer.tokenize('H\u00E9llo'			)      ,						['▁he', 'll', 'o']			)


							def    UpperCamelCase     (				self   :						Tuple			)			->					Dict:
										snake_case:    str      							=XLNetTokenizer(a_      ,						do_lower_case=a_			)
										snake_case:    List[Any]      							=tokenizer.tokenize('I was born in 92000, and this is falsé.'			)
										self.assertListEqual(
										    a_      ,						[
										        SPIECE_UNDERLINE + 'I',
										        SPIECE_UNDERLINE + 'was',
										        SPIECE_UNDERLINE + 'b',
										        'or',
										        'n',
										        SPIECE_UNDERLINE + 'in',
										        SPIECE_UNDERLINE + '',
										        '9',
										        '2',
										        '0',
										        '0',
										        '0',
										        ',',
										        SPIECE_UNDERLINE + 'and',
										        SPIECE_UNDERLINE + 'this',
										        SPIECE_UNDERLINE + 'is',
										        SPIECE_UNDERLINE + 'f',
										        'al',
										        'se',
										        '.',
										    ]      ,						)


							@slow
							def    UpperCamelCase     (				self   :						List[str]			)			->					Optional[Any]:
										snake_case:    Tuple      							=XLNetTokenizer.from_pretrained('xlnet-base-cased'			)

										snake_case:    Optional[Any]      							=tokenizer.encode('sequence builders'      ,						add_special_tokens=a_			)
										snake_case:    List[str]      							=tokenizer.encode('multi-sequence build'      ,						add_special_tokens=a_			)

										snake_case:    Optional[Any]      							=tokenizer.build_inputs_with_special_tokens(a_			)
										snake_case:    Any      							=tokenizer.build_inputs_with_special_tokens(a_      ,						a_			)

										assert encoded_sentence == text + [4, 3]
										assert encoded_pair == text + [4] + text_a + [4, 3]




							@slow
							def    UpperCamelCase     (				self   :						Dict			)			->					Optional[int]:
										# fmt: off
										snake_case:    Dict      							={'input_ids': [[1_7, 2_1_4_4_2, 2_7_0, 1_7, 1_0, 1_4_6_4_5, 3_1_8, 3_4, 1_7, 4_5_4_6, 3_1_4_5, 7_8_7, 1_3, 7_7_5_2, 2_2_0_1_8, 2_3, 2_1, 1_7, 4_5_4_6, 3_1_4_5, 7_8_7, 1_3, 3_3_5_2, 1_4_4_3_1, 1_3, 5_5_0_0, 1_1, 1_1_7_6, 5_8_0, 1_3, 1_6_8_1_9, 4_7_9_7, 2_3, 1_7, 1_0, 1_7_1_3_5, 6_5_8, 1_9, 4_5_7, 7_9_3_2, 1_3, 1_8_4, 1_9, 3_1_5_4, 1_7_1_3_5, 6_4_6_8, 1_9, 1_4_0_4, 1_2_2_6_9, 1_9, 4_2_2_9, 5_3_5_6, 1_6_2_6_4, 4_6, 1_9, 1_7, 2_0_5_4_5, 1_0_3_9_5, 9, 9, 9, 1_1, 2_8, 6_4_2_1, 9_5_3_1, 2_0_7_2_9, 1_7, 1_0, 3_5_3, 1_7_0_2_2, 1_1, 2_1, 6_4_2_1, 9_5_3_1, 1_6_9_4_9, 1_7, 1_0, 1_1_5_0_9, 7_5_3, 1_1, 3_3, 9_5, 2_4_2_1, 7_3_8_5, 9_5_6, 1_4_4_3_1, 2_6_2_6, 2_5, 8_4_2, 7_3_8_5, 4_8_3_6, 2_1, 1_4_2_9, 2_2_7_2, 9_8_5_5, 3_1_2_0, 1_6_1, 2_4_7_3_8, 1_9, 1_3_2_0_3, 6_5_8, 2_1_8, 7_8_7, 2_1, 4_3_0, 1_8_4_8_2, 8_4_7, 2_6_3_7, 9, 4, 3], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 3_2_2, 2_2_1_7_8, 2_7, 1_0_6_4, 2_2, 9_5_6, 1_3, 1_1_1_0_1, 1_4_2_9, 5_8_5_4, 2_4_3_1_3, 1_8_9_5_3, 4_0, 4_2_2, 2_4_3_6_6, 6_8, 1_7_5_8, 3_7, 1_0_4_8_3, 1_4_2_5_7, 3_1, 2_0_7, 2_6_3, 2_1, 2_0_3, 3_7_7_3, 2_5, 7_1, 9_7_3_5, 9, 4, 3], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 3_2, 2_0_4_9, 3_4_4_2, 1_7, 1_3_8_9_4, 3_3_8_0, 2_3, 9_5, 1_8, 1_7_6_3_4, 2_2_8_8, 9, 4, 3]], 'token_type_ids': [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2]], 'attention_mask': [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]}  # noqa: E501
										# fmt: on

										self.tokenizer_integration_test_util(
										    expected_encoding=a_      ,						model_name='xlnet-base-cased'      ,						revision='c841166438c31ec7ca9a106dee7bb312b73ae511'      ,						)




