






import json
import os
import re
import shutil
import tempfile
import unittest
from typing import Tuple

from transformers import AddedToken, BatchEncoding, PerceiverTokenizer
from transformers.utils import cached_property, is_tf_available, is_torch_available

from ...test_tokenization_common import TokenizerTesterMixin


if is_torch_available():
		__UpperCAmelCase      				=		'pt'
elif is_tf_available():
		__UpperCAmelCase      				=		'tf'
else:
		__UpperCAmelCase      				=		'jax'



class     lowerCamelCase (_UpperCamelCase					,    unittest.TestCase     ):







		'''simple docstring'''



		_snake_case       :       int					=    PerceiverTokenizer
		_snake_case       :       List[Any]					=    False



		def    __UpperCAmelCase     (				self  )      ->				int:
							super().setUp()
							UpperCAmelCase_       : Optional[Any]				=		PerceiverTokenizer()
							tokenizer.save_pretrained(self.tmpdirname  )



		@cached_property
		def    __UpperCAmelCase     (				self  )      ->				int:
							return PerceiverTokenizer.from_pretrained('deepmind/language-perceiver'  )



		def    __UpperCAmelCase     (				self							,						**_UpperCamelCase  )      ->				Union[str, Any]:
							return self.tokenizer_class.from_pretrained(self.tmpdirname							,						**lowercase__  )



		def    __UpperCAmelCase     (				self							,						_UpperCamelCase							,						_UpperCamelCase=False							,						_UpperCamelCase=2_0							,						_UpperCamelCase=5  )      ->				Tuple:
							# XXX The default common tokenizer tests assume that every ID is decodable on its own.
							# This assumption is invalid for Perceiver because single bytes might not be
							# valid utf-8 (byte 128 for instance).
							# Here we're overriding the smallest possible method to provide
							# a clean sequence without making the same assumption.

							UpperCAmelCase_       : Union[str, Any]				=		[]
							for i in range(len(lowercase__  )  ):
												try:
																	UpperCAmelCase_       : Union[str, Any]				=		tokenizer.decode([i]							,						clean_up_tokenization_spaces=lowercase__  )
												except UnicodeDecodeError:
																	pass
												toks.append((i, tok)  )

							UpperCAmelCase_       : List[Any]				=		list(filter(lambda _UpperCamelCase  : re.match(r'^[ a-zA-Z]+$'							,						t[1]  )							,						lowercase__  )  )
							UpperCAmelCase_       : Any				=		list(filter(lambda _UpperCamelCase  : [t[0]] == tokenizer.encode(t[1]							,						add_special_tokens=lowercase__  )							,						lowercase__  )  )
							if max_length is not None and len(lowercase__  ) > max_length:
												UpperCAmelCase_       : str				=		toks[:max_length]
							if min_length is not None and len(lowercase__  ) < min_length and len(lowercase__  ) > 0:
												while len(lowercase__  ) < min_length:
																	UpperCAmelCase_       : Dict				=		toks + toks
        # toks_str = [t[1] for t in toks]
							UpperCAmelCase_       : Optional[Any]				=		[t[0] for t in toks]

							# Ensure consistency
							UpperCAmelCase_       : Any				=		tokenizer.decode(lowercase__							,						clean_up_tokenization_spaces=lowercase__  )
							if " " not in output_txt and len(lowercase__  ) > 1:
												UpperCAmelCase_       : str				=		(
												    tokenizer.decode([toks_ids[0]]							,						clean_up_tokenization_spaces=lowercase__  )
												    + ''' '''
												    + tokenizer.decode(toks_ids[1:]							,						clean_up_tokenization_spaces=lowercase__  )
												)
							if with_prefix_space:
												UpperCAmelCase_       : List[Any]				=		''' ''' + output_txt
							UpperCAmelCase_       : Optional[int]				=		tokenizer.encode(lowercase__							,						add_special_tokens=lowercase__  )
							return output_txt, output_ids



		def    __UpperCAmelCase     (				self  )      ->				List[str]:
							UpperCAmelCase_       : Tuple				=		self.perceiver_tokenizer
							UpperCAmelCase_       : Dict				=		'''Unicode €.'''
							UpperCAmelCase_       : Tuple				=		tokenizer(lowercase__  )
							UpperCAmelCase_       : str				=		[4, 9_1, 1_1_6, 1_1_1, 1_0_5, 1_1_7, 1_0_6, 1_0_7, 3_8, 2_3_2, 1_3_6, 1_7_8, 5_2, 5]
							self.assertEqual(encoded['input_ids']							,						lowercase__  )

							# decoding
							UpperCAmelCase_       : str				=		tokenizer.decode(lowercase__  )
							self.assertEqual(lowercase__							,						'[CLS]Unicode €.[SEP]'  )

							UpperCAmelCase_       : Optional[Any]				=		tokenizer('e è é ê ë'  )
							UpperCAmelCase_       : Tuple				=		[4, 1_0_7, 3_8, 2_0_1, 1_7_4, 3_8, 2_0_1, 1_7_5, 3_8, 2_0_1, 1_7_6, 3_8, 2_0_1, 1_7_7, 5]
							self.assertEqual(encoded['input_ids']							,						lowercase__  )
							# decoding
							UpperCAmelCase_       : Optional[int]				=		tokenizer.decode(lowercase__  )
							self.assertEqual(lowercase__							,						'[CLS]e è é ê ë[SEP]'  )

							# encode/decode, but with `encode` instead of `__call__`
							self.assertEqual(tokenizer.decode(tokenizer.encode('e è é ê ë'  )  )							,						'[CLS]e è é ê ë[SEP]'  )



		def    __UpperCAmelCase     (				self  )      ->				List[str]:
							UpperCAmelCase_       : Tuple				=		self.perceiver_tokenizer
							UpperCAmelCase_       : List[Any]				=		['''A long paragraph for summarization.''', '''Another paragraph for summarization.''']
							# fmt: off
							UpperCAmelCase_       : Optional[Any]				=		[4, 7_1, 3_8, 1_1_4, 1_1_7, 1_1_6, 1_0_9, 3_8, 1_1_8, 1_0_3, 1_2_0, 1_0_3, 1_0_9, 1_2_0, 1_0_3, 1_1_8, 1_1_0, 3_8, 1_0_8, 1_1_7, 1_2_0, 3_8, 1_2_1, 1_2_3, 1_1_5, 1_1_5, 1_0_3, 1_2_0, 1_1_1, 1_2_8, 1_0_3, 1_2_2, 1_1_1, 1_1_7, 1_1_6, 5_2, 5, 0]
							# fmt: on
							UpperCAmelCase_       : List[str]				=		tokenizer(lowercase__							,						padding=lowercase__							,						return_tensors=lowercase__  )
							self.assertIsInstance(lowercase__							,						lowercase__  )

							if FRAMEWORK != "jax":
												UpperCAmelCase_       : List[str]				=		list(batch.input_ids.numpy()[0]  )
							else:
												UpperCAmelCase_       : Union[str, Any]				=		list(batch.input_ids.tolist()[0]  )

							self.assertListEqual(lowercase__							,						lowercase__  )

							self.assertEqual((2, 3_8)							,						batch.input_ids.shape  )
							self.assertEqual((2, 3_8)							,						batch.attention_mask.shape  )



		def    __UpperCAmelCase     (				self  )      ->				Tuple:
							UpperCAmelCase_       : Union[str, Any]				=		self.perceiver_tokenizer
							UpperCAmelCase_       : List[str]				=		['''A long paragraph for summarization.''', '''Another paragraph for summarization.''']
							UpperCAmelCase_       : Dict				=		tokenizer(lowercase__							,						padding=lowercase__							,						return_tensors=lowercase__  )
							# check if input_ids are returned and no decoder_input_ids
							self.assertIn('input_ids'							,						lowercase__  )
							self.assertIn('attention_mask'							,						lowercase__  )
							self.assertNotIn('decoder_input_ids'							,						lowercase__  )
							self.assertNotIn('decoder_attention_mask'							,						lowercase__  )



		def    __UpperCAmelCase     (				self  )      ->				Tuple:
							UpperCAmelCase_       : Optional[int]				=		self.perceiver_tokenizer
							UpperCAmelCase_       : Dict				=		[
							    '''Summary of the text.''',
							    '''Another summary.''',
							]
							UpperCAmelCase_       : str				=		tokenizer(
							    text_target=lowercase__							,						max_length=3_2							,						padding='max_length'							,						truncation=lowercase__							,						return_tensors=lowercase__  )
							self.assertEqual(3_2							,						targets['input_ids'].shape[1]  )



		def    __UpperCAmelCase     (				self  )      ->				str:
							# safety check on max_len default value so we are sure the test works
							UpperCAmelCase_       : Optional[Any]				=		self.get_tokenizers()
							for tokenizer in tokenizers:
												with self.subTest(f"{tokenizer.__class__.__name__}"  ):
																	self.assertNotEqual(tokenizer.model_max_length							,						4_2  )

        # Now let's start the test
							UpperCAmelCase_       : Union[str, Any]				=		self.get_tokenizers()
							for tokenizer in tokenizers:
												with self.subTest(f"{tokenizer.__class__.__name__}"  ):
																	# Isolate this from the other tests because we save additional tokens/etc
																	UpperCAmelCase_       : str				=		tempfile.mkdtemp()

																	UpperCAmelCase_       : List[Any]				=		''' He is very happy, UNwant\u00E9d,running'''
																	UpperCAmelCase_       : Union[str, Any]				=		tokenizer.encode(lowercase__							,						add_special_tokens=lowercase__  )
																	tokenizer.save_pretrained(lowercase__  )

																	UpperCAmelCase_       : List[Any]				=		tokenizer.__class__.from_pretrained(lowercase__  )
																	UpperCAmelCase_       : Dict				=		after_tokenizer.encode(lowercase__							,						add_special_tokens=lowercase__  )
																	self.assertListEqual(lowercase__							,						lowercase__  )

																	shutil.rmtree(lowercase__  )

							UpperCAmelCase_       : List[str]				=		self.get_tokenizers(model_max_length=4_2  )
							for tokenizer in tokenizers:
												with self.subTest(f"{tokenizer.__class__.__name__}"  ):
																	# Isolate this from the other tests because we save additional tokens/etc
																	UpperCAmelCase_       : Union[str, Any]				=		tempfile.mkdtemp()

																	UpperCAmelCase_       : List[str]				=		''' He is very happy, UNwant\u00E9d,running'''
																	tokenizer.add_tokens(['bim', 'bambam']  )
																	UpperCAmelCase_       : Optional[Any]				=		tokenizer.additional_special_tokens
																	additional_special_tokens.append('new_additional_special_token'  )
																	tokenizer.add_special_tokens({'additional_special_tokens': additional_special_tokens}  )
																	UpperCAmelCase_       : List[str]				=		tokenizer.encode(lowercase__							,						add_special_tokens=lowercase__  )
																	tokenizer.save_pretrained(lowercase__  )

																	UpperCAmelCase_       : Tuple				=		tokenizer.__class__.from_pretrained(lowercase__  )
																	UpperCAmelCase_       : Dict				=		after_tokenizer.encode(lowercase__							,						add_special_tokens=lowercase__  )
																	self.assertListEqual(lowercase__							,						lowercase__  )
																	self.assertIn('new_additional_special_token'							,						after_tokenizer.additional_special_tokens  )
																	self.assertEqual(after_tokenizer.model_max_length							,						4_2  )

																	UpperCAmelCase_       : Any				=		tokenizer.__class__.from_pretrained(lowercase__							,						model_max_length=4_3  )
																	self.assertEqual(tokenizer.model_max_length							,						4_3  )

																	shutil.rmtree(lowercase__  )



		def    __UpperCAmelCase     (				self  )      ->				int:
							UpperCAmelCase_       : int				=		[]
							if self.test_slow_tokenizer:
												tokenizer_list.append((self.tokenizer_class, self.get_tokenizer())  )

							if self.test_rust_tokenizer:
												tokenizer_list.append((self.rust_tokenizer_class, self.get_rust_tokenizer())  )

							for tokenizer_class, tokenizer_utils in tokenizer_list:
												with tempfile.TemporaryDirectory() as tmp_dir:
																	tokenizer_utils.save_pretrained(lowercase__  )

																	with open(os.path.join(lowercase__							,						'special_tokens_map.json'  )							,						encoding='utf-8'  ) as json_file:
																						UpperCAmelCase_       : Optional[Any]				=		json.load(lowercase__  )

																	with open(os.path.join(lowercase__							,						'tokenizer_config.json'  )							,						encoding='utf-8'  ) as json_file:
																						UpperCAmelCase_       : Any				=		json.load(lowercase__  )

																	UpperCAmelCase_       : Tuple				=		[f"<extra_id_{i}>" for i in range(1_2_5  )]

																	UpperCAmelCase_       : str				=		added_tokens_extra_ids + [
																	    '''an_additional_special_token'''
																	]
																	UpperCAmelCase_       : Union[str, Any]				=		added_tokens_extra_ids + [
																	    '''an_additional_special_token'''
																	]

																	with open(os.path.join(lowercase__							,						'special_tokens_map.json'  )							,						'w'							,						encoding='utf-8'  ) as outfile:
																						json.dump(lowercase__							,						lowercase__  )
																	with open(os.path.join(lowercase__							,						'tokenizer_config.json'  )							,						'w'							,						encoding='utf-8'  ) as outfile:
																						json.dump(lowercase__							,						lowercase__  )

																	# the following checks allow us to verify that our test works as expected, i.e. that the tokenizer takes
																	# into account the new value of additional_special_tokens given in the "tokenizer_config.json" and
																	# "special_tokens_map.json" files
																	UpperCAmelCase_       : Optional[Any]				=		tokenizer_class.from_pretrained(
																	    lowercase__							,						)
																	self.assertIn(
																	    'an_additional_special_token'							,						tokenizer_without_change_in_init.additional_special_tokens  )
																	self.assertEqual(
																	    ['an_additional_special_token']							,						tokenizer_without_change_in_init.convert_ids_to_tokens(
																	        tokenizer_without_change_in_init.convert_tokens_to_ids(['an_additional_special_token']  )  )							,						)

																	# Now we test that we can change the value of additional_special_tokens in the from_pretrained
																	UpperCAmelCase_       : Tuple				=		added_tokens_extra_ids + [AddedToken('a_new_additional_special_token'							,						lstrip=lowercase__  )]
																	UpperCAmelCase_       : List[str]				=		tokenizer_class.from_pretrained(
																	    lowercase__							,						additional_special_tokens=lowercase__							,						)

																	self.assertIn('a_new_additional_special_token'							,						tokenizer.additional_special_tokens  )
																	self.assertEqual(
																	    ['a_new_additional_special_token']							,						tokenizer.convert_ids_to_tokens(
																	        tokenizer.convert_tokens_to_ids(['a_new_additional_special_token']  )  )							,						)



		def    __UpperCAmelCase     (				self  )      ->				Dict:
							UpperCAmelCase_       : Tuple				=		self.perceiver_tokenizer
							self.assertEqual(tokenizer.decode([1_7_8]  )							,						'�'  )



		def    __UpperCAmelCase     (				self  )      ->				Dict:
							pass



		def    __UpperCAmelCase     (				self  )      ->				List[str]:
							pass



		def    __UpperCAmelCase     (				self  )      ->				Any:
							pass



		def    __UpperCAmelCase     (				self  )      ->				Any:
							pass



		def    __UpperCAmelCase     (				self  )      ->				int:
							# The default common tokenizer tests uses invalid tokens for Perceiver that can only accept one-character
							# strings and special added tokens as tokens
							UpperCAmelCase_       : str				=		self.get_tokenizers(fast=lowercase__							,						do_lower_case=lowercase__  )
							for tokenizer in tokenizers:
												with self.subTest(f"{tokenizer.__class__.__name__}"  ):
																	UpperCAmelCase_       : int				=		['''[CLS]''', '''t''', '''h''', '''i''', '''s''', ''' ''', '''i''', '''s''', ''' ''', '''a''', ''' ''', '''t''', '''e''', '''s''', '''t''', '''[SEP]''']
																	UpperCAmelCase_       : List[Any]				=		tokenizer.convert_tokens_to_string(lowercase__  )

																	self.assertIsInstance(lowercase__							,						lowercase__  )










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


lowerCAmelCase       		=    get_tests_dir("""fixtures/test_sentencepiece.model""")




@require_sentencepiece
@require_tokenizers
class 							lowerCamelCase   (  _UpperCamelCase							,						unittest.TestCase ):
	_lowerCAmelCase     :		Union[str, Any]										=						XLNetTokenizer
	_lowerCAmelCase     :		int										=						XLNetTokenizerFast
	_lowerCAmelCase     :		Optional[Any]										=						True
	_lowerCAmelCase     :		Optional[Any]										=						True


	def  A(    self):
							super().setUp()

							# We have a SentencePiece fixture for testing
							__UpperCAmelCase			:							Optional[Any]	    =	XLNetTokenizer(lowercase__				,     keep_accents=lowercase__)
							tokenizer.sanitize_special_tokens()
							tokenizer.save_pretrained(self.tmpdirname)


	def  A(    self):
							__UpperCAmelCase			:							Tuple	    =	'''<s>'''
							__UpperCAmelCase			:							List[str]	    =	1

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


	def  A(    self):
							__UpperCAmelCase			:							Union[str, Any]	    =	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(lowercase__)				,     1_0_0_6)


	def  A(    self):
							self.assertEqual(self.get_tokenizer().vocab_size				,     1_0_0_0)


	def  A(    self):
							__UpperCAmelCase			:							List[str]	    =	XLNetTokenizer(lowercase__				,     keep_accents=lowercase__)

							__UpperCAmelCase			:							Optional[Any]	    =	tokenizer.tokenize('''This is a test''')
							self.assertListEqual(lowercase__				,     ['''▁This''', '''▁is''', '''▁a''', '''▁t''', '''est'''])

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

							__UpperCAmelCase			:							Tuple	    =	tokenizer.tokenize('''I was born in 92000, and this is falsé.''')
							self.assertListEqual(
							    lowercase__				,     [
							        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''',
							        '''é''',
							        '''.''',
							    ]				,     )
							__UpperCAmelCase			:							Union[str, Any]	    =	tokenizer.convert_tokens_to_ids(lowercase__)
							self.assertListEqual(lowercase__				,     [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])

							__UpperCAmelCase			:							int	    =	tokenizer.convert_ids_to_tokens(lowercase__)
							self.assertListEqual(
							    lowercase__				,     [
							        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  A(    self):
							__UpperCAmelCase			:							str	    =	XLNetTokenizer(lowercase__				,     do_lower_case=lowercase__)
							__UpperCAmelCase			:							int	    =	tokenizer.tokenize('''I was born in 92000, and this is falsé.''')
							self.assertListEqual(
							    lowercase__				,     [
							        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  A(    self):
							__UpperCAmelCase			:							Optional[Any]	    =	XLNetTokenizer(lowercase__				,     do_lower_case=lowercase__)
							__UpperCAmelCase			:							Union[str, Any]	    =	tokenizer.tokenize('''I was born in 92000, and this is falsé.''')
							self.assertListEqual(
							    lowercase__				,     [
							        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  A(    self):
							__UpperCAmelCase			:							Tuple	    =	XLNetTokenizer.from_pretrained('''xlnet-base-cased''')

							__UpperCAmelCase			:							Optional[int]	    =	tokenizer.encode('''sequence builders'''				,     add_special_tokens=lowercase__)
							__UpperCAmelCase			:							Optional[int]	    =	tokenizer.encode('''multi-sequence build'''				,     add_special_tokens=lowercase__)

							__UpperCAmelCase			:							Union[str, Any]	    =	tokenizer.build_inputs_with_special_tokens(lowercase__)
							__UpperCAmelCase			:							Optional[Any]	    =	tokenizer.build_inputs_with_special_tokens(lowercase__				,     lowercase__)

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


	@slow
	def  A(    self):
							# fmt: off
							__UpperCAmelCase			:							Optional[Any]	    =	{'''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=lowercase__				,     model_name='''xlnet-base-cased'''				,     revision='''c841166438c31ec7ca9a106dee7bb312b73ae511'''				,     )

