


from google.protobuf import descriptor as _descriptor
from google.protobuf import descriptor_pool as _descriptor_pool
from google.protobuf import symbol_database as _symbol_database
from google.protobuf.internal import builder as _builder


# @@protoc_insertion_point(imports)

lowerCamelCase		   =			_symbol_database.Default()


lowerCamelCase		   =			_descriptor_pool.Default().AddSerializedFile(
    B'\n\x19sentencepiece_model.proto\x12\rsentencepiece"\x80\x0c\n\x0bTrainerSpec\x12\r\n\x05input\x18\x01 \x03(\t\x12\x14\n\x0cinput_format\x18\x07 \x01(\t\x12\x14\n\x0cmodel_prefix\x18\x02 \x01(\t\x12\x41\n\nmodel_type\x18\x03 \x01(\x0e\x32$.sentencepiece.TrainerSpec.ModelType:\x07UNIGRAM\x12\x18\n\nvocab_size\x18\x04 \x01(\x05:\x04\x38\x30\x30\x30\x12\x17\n\x0f\x61\x63\x63\x65pt_language\x18\x05 \x03(\t\x12 \n\x15self_test_sample_size\x18\x06 \x01(\x05:\x01\x30\x12*\n\x1b\x65nable_differential_privacy\x18\x32 \x01(\x08:\x05\x66\x61lse\x12+\n differential_privacy_noise_level\x18\x33 \x01(\x02:\x01\x30\x12\x32\n\'differential_privacy_clipping_threshold\x18\x34 \x01(\x04:\x01\x30\x12"\n\x12\x63haracter_coverage\x18\n \x01(\x02:\x06\x30.9995\x12\x1e\n\x13input_sentence_size\x18\x0b \x01(\x04:\x01\x30\x12$\n\x16shuffle_input_sentence\x18\x13 \x01(\x08:\x04true\x12 \n\x14mining_sentence_size\x18\x0c \x01(\x05\x42\x02\x18\x01\x12"\n\x16training_sentence_size\x18\r \x01(\x05\x42\x02\x18\x01\x12(\n\x17seed_sentencepiece_size\x18\x0e \x01(\x05:\x07\x31\x30\x30\x30\x30\x30\x30\x12\x1e\n\x10shrinking_factor\x18\x0f \x01(\x02:\x04\x30.75\x12!\n\x13max_sentence_length\x18\x12 \x01(\x05:\x04\x34\x31\x39\x32\x12\x17\n\x0bnum_threads\x18\x10 \x01(\x05:\x02\x31\x36\x12\x1d\n\x12num_sub_iterations\x18\x11 \x01(\x05:\x01\x32\x12$\n\x18max_sentencepiece_length\x18\x14 \x01(\x05:\x02\x31\x36\x12%\n\x17split_by_unicode_script\x18\x15 \x01(\x08:\x04true\x12\x1d\n\x0fsplit_by_number\x18\x17 \x01(\x08:\x04true\x12!\n\x13split_by_whitespace\x18\x16 \x01(\x08:\x04true\x12)\n\x1atreat_whitespace_as_suffix\x18\x18 \x01(\x08:\x05\x66\x61lse\x12+\n\x1c\x61llow_whitespace_only_pieces\x18\x1a \x01(\x08:\x05\x66\x61lse\x12\x1b\n\x0csplit_digits\x18\x19 \x01(\x08:\x05\x66\x61lse\x12#\n\x19pretokenization_delimiter\x18\x35 \x01(\t:\x00\x12\x17\n\x0f\x63ontrol_symbols\x18\x1e \x03(\t\x12\x1c\n\x14user_defined_symbols\x18\x1f \x03(\t\x12\x16\n\x0erequired_chars\x18$ \x01(\t\x12\x1c\n\rbyte_fallback\x18# \x01(\x08:\x05\x66\x61lse\x12+\n\x1dvocabulary_output_piece_score\x18  \x01(\x08:\x04true\x12\x1e\n\x10hard_vocab_limit\x18! \x01(\x08:\x04true\x12\x1c\n\ruse_all_vocab\x18" \x01(\x08:\x05\x66\x61lse\x12\x11\n\x06unk_id\x18( \x01(\x05:\x01\x30\x12\x11\n\x06\x62os_id\x18) \x01(\x05:\x01\x31\x12\x11\n\x06\x65os_id\x18* \x01(\x05:\x01\x32\x12\x12\n\x06pad_id\x18+ \x01(\x05:\x02-1\x12\x18\n\tunk_piece\x18- \x01(\t:\x05<unk>\x12\x16\n\tbos_piece\x18. \x01(\t:\x03<s>\x12\x17\n\teos_piece\x18/ \x01(\t:\x04</s>\x12\x18\n\tpad_piece\x18\x30 \x01(\t:\x05<pad>\x12\x1a\n\x0bunk_surface\x18, \x01(\t:\x05 \xe2\x81\x87 \x12+\n\x1ctrain_extremely_large_corpus\x18\x31 \x01(\x08:\x05\x66\x61lse"5\n\tModelType\x12\x0b\n\x07UNIGRAM\x10\x01\x12\x07\n\x03\x42PE\x10\x02\x12\x08\n\x04WORD\x10\x03\x12\x08\n\x04\x43HAR\x10\x04*\t\x08\xc8\x01\x10\x80\x80\x80\x80\x02"\xd1\x01\n\x0eNormalizerSpec\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x1c\n\x14precompiled_charsmap\x18\x02 \x01(\x0c\x12\x1e\n\x10\x61\x64\x64_dummy_prefix\x18\x03 \x01(\x08:\x04true\x12&\n\x18remove_extra_whitespaces\x18\x04 \x01(\x08:\x04true\x12 \n\x12\x65scape_whitespaces\x18\x05 \x01(\x08:\x04true\x12\x1e\n\x16normalization_rule_tsv\x18\x06 \x01(\t*\t\x08\xc8\x01\x10\x80\x80\x80\x80\x02"y\n\x0cSelfTestData\x12\x33\n\x07samples\x18\x01 \x03(\x0b\x32".sentencepiece.SelfTestData.Sample\x1a)\n\x06Sample\x12\r\n\x05input\x18\x01 \x01(\t\x12\x10\n\x08\x65xpected\x18\x02 \x01(\t*\t\x08\xc8\x01\x10\x80\x80\x80\x80\x02"\xfe\x03\n\nModelProto\x12\x37\n\x06pieces\x18\x01 \x03(\x0b\x32\'.sentencepiece.ModelProto.SentencePiece\x12\x30\n\x0ctrainer_spec\x18\x02 \x01(\x0b\x32\x1a.sentencepiece.TrainerSpec\x12\x36\n\x0fnormalizer_spec\x18\x03 \x01(\x0b\x32\x1d.sentencepiece.NormalizerSpec\x12\x33\n\x0eself_test_data\x18\x04 \x01(\x0b\x32\x1b.sentencepiece.SelfTestData\x12\x38\n\x11\x64\x65normalizer_spec\x18\x05 \x01(\x0b\x32\x1d.sentencepiece.NormalizerSpec\x1a\xd2\x01\n\rSentencePiece\x12\r\n\x05piece\x18\x01 \x01(\t\x12\r\n\x05score\x18\x02 \x01(\x02\x12\x42\n\x04type\x18\x03 \x01(\x0e\x32,.sentencepiece.ModelProto.SentencePiece.Type:\x06NORMAL"T\n\x04Type\x12\n\n\x06NORMAL\x10\x01\x12\x0b\n\x07UNKNOWN\x10\x02\x12\x0b\n\x07\x43ONTROL\x10\x03\x12\x10\n\x0cUSER_DEFINED\x10\x04\x12\x08\n\x04\x42YTE\x10\x06\x12\n\n\x06UNUSED\x10\x05*\t\x08\xc8\x01\x10\x80\x80\x80\x80\x02*\t\x08\xc8\x01\x10\x80\x80\x80\x80\x02\x42\x02H\x03'
)

lowerCamelCase		   =			globals()
_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'sentencepiece_model_pb2', _globals)
if _descriptor._USE_C_DESCRIPTORS is False:
 lowerCamelCase		   =			None
 lowerCamelCase		   =			B'H\003'
 # (generated by protobuf compiler, but `_TRAINERSPEC` is not defined)
 # _TRAINERSPEC.fields_by_name["mining_sentence_size"]._options = None
 # _TRAINERSPEC.fields_by_name["mining_sentence_size"]._serialized_options = b"\030\001"
 # _TRAINERSPEC.fields_by_name["training_sentence_size"]._options = None
 # _TRAINERSPEC.fields_by_name["training_sentence_size"]._serialized_options = b"\030\001"
 lowerCamelCase		   =			45
 lowerCamelCase		   =			15_81
 lowerCamelCase		   =			15_17
 lowerCamelCase		   =			15_70
 lowerCamelCase		   =			15_84
 lowerCamelCase		   =			17_93
 lowerCamelCase		   =			17_95
 lowerCamelCase		   =			19_16
 lowerCamelCase		   =			18_64
 lowerCamelCase		   =			19_05
 lowerCamelCase		   =			19_19
 lowerCamelCase		   =			24_29
 lowerCamelCase		   =			22_08
 lowerCamelCase		   =			24_18
 lowerCamelCase		   =			23_23
 lowerCamelCase		   =			24_07
# @@protoc_insertion_point(module_scope)






import pickle
import shutil
import tempfile
import unittest

from transformers import SPIECE_UNDERLINE, XLMRobertaTokenizer, XLMRobertaTokenizerFast
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, slow
from transformers.utils import cached_property

from ...test_tokenization_common import TokenizerTesterMixin


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




@require_sentencepiece
@require_tokenizers
class A    (  UpperCamelCase_       ,				unittest.TestCase	):
      UpperCamelCase__				:    List[Any] =XLMRobertaTokenizer
      UpperCamelCase__				:    Union[str, Any] =XLMRobertaTokenizerFast
      UpperCamelCase__				:    int =True
      UpperCamelCase__				:    Optional[Any] =True






      def 			lowerCamelCase			(   self		:	List[Any]					)   ->		Dict:
             """simple docstring"""




             super().setUp()

             # We have a SentencePiece fixture for testing
             _lowerCamelCase			:						Dict            =XLMRobertaTokenizer(lowercase_     ,  keep_accents=lowercase_					)
             tokenizer.save_pretrained(self.tmpdirname					)






      def 			lowerCamelCase			(   self		:	Dict					)   ->		Any:
             """simple docstring"""




             _lowerCamelCase			:						Tuple            ='<pad>'
             _lowerCamelCase			:						Optional[int]            =1

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






      def 			lowerCamelCase			(   self		:	Any					)   ->		Optional[int]:
             """simple docstring"""




             _lowerCamelCase			:						str            =list(self.get_tokenizer().get_vocab().keys()					)

             self.assertEqual(vocab_keys[0]     ,  '<s>'					)
             self.assertEqual(vocab_keys[1]     ,  '<pad>'					)
             self.assertEqual(vocab_keys[-1]     ,  '<mask>'					)
             self.assertEqual(len(lowercase_					)     ,  1002					)






      def 			lowerCamelCase			(   self		:	int					)   ->		Optional[Any]:
             """simple docstring"""




             self.assertEqual(self.get_tokenizer().vocab_size     ,  1002					)






      def 			lowerCamelCase			(   self		:	Tuple					)   ->		Union[str, Any]:
             """simple docstring"""




             _lowerCamelCase			:						Optional[Any]            =XLMRobertaTokenizer(lowercase_     ,  keep_accents=lowercase_					)

             _lowerCamelCase			:						List[Any]            =tokenizer.tokenize('This is a test'					)
             self.assertListEqual(lowercase_     ,  ['▁This', '▁is', '▁a', '▁t', 'est']					)

             self.assertListEqual(
                 tokenizer.convert_tokens_to_ids(lowercase_					)     ,  [value + tokenizer.fairseq_offset for value in [285, 46, 10, 170, 382]]     ,  )

             _lowerCamelCase			:						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',
                     's',
                     'é',
                     '.',
                 ]     ,  )
             _lowerCamelCase			:						Optional[Any]            =tokenizer.convert_tokens_to_ids(lowercase_					)
             self.assertListEqual(
                 lowercase_     ,  [
                     value + tokenizer.fairseq_offset
                     for value in [8, 21, 84, 55, 24, 19, 7, 2, 602, 347, 347, 347, 3, 12, 66, 46, 72, 80, 6, 2, 4]
                     #                                       ^ unk: 2 + 1 = 3                  unk: 2 + 1 = 3 ^
                 ]     ,  )

             _lowerCamelCase			:						Optional[Any]            =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 			lowerCamelCase			(   self		:	List[Any]					)   ->		Any:
             """simple docstring"""




             if not self.test_slow_tokenizer:
                    # as we don't have a slow version, we can't compare the outputs between slow and fast versions
                    return

             _lowerCamelCase			:						List[str]            =(self.rust_tokenizer_class, 'hf-internal-testing/tiny-xlm-roberta', {})
             for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
                    with self.subTest(F'''{tokenizer.__class__.__name__} ({pretrained_name})'''					):
                           _lowerCamelCase			:						int            =self.rust_tokenizer_class.from_pretrained(lowercase_     ,  **lowercase_					)
                           _lowerCamelCase			:						List[Any]            =self.tokenizer_class.from_pretrained(lowercase_     ,  **lowercase_					)

                           _lowerCamelCase			:						int            =tempfile.mkdtemp()

                           _lowerCamelCase			:						List[str]            =tokenizer_r.save_pretrained(lowercase_					)
                           _lowerCamelCase			:						int            =tokenizer_p.save_pretrained(lowercase_					)

                           # Checks it save with the same files + the tokenizer.json file for the fast one
                           self.assertTrue(any('tokenizer.json' in f for f in tokenizer_r_files					)					)
                           _lowerCamelCase			:						Optional[Any]            =tuple(f for f in tokenizer_r_files if 'tokenizer.json' not in f					)
                           self.assertSequenceEqual(lowercase_     ,  lowercase_					)

                           # Checks everything loads correctly in the same way
                           _lowerCamelCase			:						int            =tokenizer_r.from_pretrained(lowercase_					)
                           _lowerCamelCase			:						Any            =tokenizer_p.from_pretrained(lowercase_					)

                           # Check special tokens are set accordingly on Rust and Python
                           for key in tokenizer_pp.special_tokens_map:
                                  self.assertTrue(hasattr(lowercase_     ,  lowercase_					)					)
                                  # self.assertEqual(getattr(tokenizer_rp, key), getattr(tokenizer_pp, key))
                                  # self.assertEqual(getattr(tokenizer_rp, key + "_id"), getattr(tokenizer_pp, key + "_id"))

                           shutil.rmtree(lowercase_					)

                           # Save tokenizer rust, legacy_format=True
                           _lowerCamelCase			:						Dict            =tempfile.mkdtemp()

                           _lowerCamelCase			:						int            =tokenizer_r.save_pretrained(lowercase_     ,  legacy_format=lowercase_					)
                           _lowerCamelCase			:						Optional[Any]            =tokenizer_p.save_pretrained(lowercase_					)

                           # Checks it save with the same files
                           self.assertSequenceEqual(lowercase_     ,  lowercase_					)

                           # Checks everything loads correctly in the same way
                           _lowerCamelCase			:						int            =tokenizer_r.from_pretrained(lowercase_					)
                           _lowerCamelCase			:						List[Any]            =tokenizer_p.from_pretrained(lowercase_					)

                           # Check special tokens are set accordingly on Rust and Python
                           for key in tokenizer_pp.special_tokens_map:
                                  self.assertTrue(hasattr(lowercase_     ,  lowercase_					)					)

                           shutil.rmtree(lowercase_					)

                           # Save tokenizer rust, legacy_format=False
                           _lowerCamelCase			:						str            =tempfile.mkdtemp()

                           _lowerCamelCase			:						Optional[Any]            =tokenizer_r.save_pretrained(lowercase_     ,  legacy_format=lowercase_					)
                           _lowerCamelCase			:						Any            =tokenizer_p.save_pretrained(lowercase_					)

                           # Checks it saved the tokenizer.json file
                           self.assertTrue(any('tokenizer.json' in f for f in tokenizer_r_files					)					)

                           # Checks everything loads correctly in the same way
                           _lowerCamelCase			:						str            =tokenizer_r.from_pretrained(lowercase_					)
                           _lowerCamelCase			:						List[str]            =tokenizer_p.from_pretrained(lowercase_					)

                           # Check special tokens are set accordingly on Rust and Python
                           for key in tokenizer_pp.special_tokens_map:
                                  self.assertTrue(hasattr(lowercase_     ,  lowercase_					)					)

                           shutil.rmtree(lowercase_					)






      @cached_property
      def 			lowerCamelCase			(   self		:	List[str]					)   ->		List[Any]:
             """simple docstring"""




             return XLMRobertaTokenizer.from_pretrained('xlm-roberta-base'					)






      def 			lowerCamelCase			(   self		:	Tuple					)   ->		Dict:
             """simple docstring"""




             with tempfile.NamedTemporaryFile() as f:
                    shutil.copyfile(lowercase_     ,  f.name					)
                    _lowerCamelCase			:						Union[str, Any]            =XLMRobertaTokenizer(f.name     ,  keep_accents=lowercase_					)
                    _lowerCamelCase			:						Dict            =pickle.dumps(lowercase_					)
             pickle.loads(lowercase_					)






      def 			lowerCamelCase			(   self		:	Dict					)   ->		Union[str, Any]:
             """simple docstring"""




             if not self.test_rust_tokenizer:
                    return

             _lowerCamelCase			:						Any            =self.get_tokenizer()
             _lowerCamelCase			:						Optional[int]            =self.get_rust_tokenizer()

             _lowerCamelCase			:						Tuple            ='I was born in 92000, and this is falsé.'

             _lowerCamelCase			:						Any            =tokenizer.tokenize(lowercase_					)
             _lowerCamelCase			:						List[str]            =rust_tokenizer.tokenize(lowercase_					)
             self.assertListEqual(lowercase_     ,  lowercase_					)

             _lowerCamelCase			:						int            =tokenizer.encode(lowercase_     ,  add_special_tokens=lowercase_					)
             _lowerCamelCase			:						Union[str, Any]            =rust_tokenizer.encode(lowercase_     ,  add_special_tokens=lowercase_					)
             self.assertListEqual(lowercase_     ,  lowercase_					)

             _lowerCamelCase			:						Dict            =self.get_rust_tokenizer()
             _lowerCamelCase			:						Optional[int]            =tokenizer.encode(lowercase_					)
             _lowerCamelCase			:						Optional[Any]            =rust_tokenizer.encode(lowercase_					)
             self.assertListEqual(lowercase_     ,  lowercase_					)






      @slow
      def 			lowerCamelCase			(   self		:	Optional[int]					)   ->		Optional[int]:
             """simple docstring"""




             _lowerCamelCase			:						Optional[Any]            ='Hello World!'
             _lowerCamelCase			:						Union[str, Any]            =[0, 3_5378, 6661, 38, 2]
             # xlmr = torch.hub.load('pytorch/fairseq', 'xlmr.base')  # xlmr.large has same tokenizer
             # xlmr.eval()
             # xlmr.encode(symbols)

             self.assertListEqual(lowercase_     ,  self.big_tokenizer.encode(lowercase_					)					)






      @slow
      def 			lowerCamelCase			(   self		:	Any					)   ->		int:
             """simple docstring"""




             _lowerCamelCase			:						Union[str, Any]            =(
                 'This is a very long text with a lot of weird characters, such as: . , ~ ? ( ) " [ ] ! : - . Also we will'
                 ' add words that should not exsist and be tokenized to <unk>, such as saoneuhaoesuth'
             )
             _lowerCamelCase			:						List[str]            =[
                 0,
                 3293,
                 83,
                 10,
                 4552,
                 4989,
                 7986,
                 678,
                 10,
                 5915,
                 111,
                 17_9459,
                 12_4850,
                 4,
                 6044,
                 237,
                 12,
                 6,
                 5,
                 6,
                 4,
                 6780,
                 705,
                 15,
                 1388,
                 44,
                 378,
                 1_0114,
                 711,
                 152,
                 20,
                 6,
                 5,
                 2_2376,
                 642,
                 1221,
                 1_5190,
                 3_4153,
                 450,
                 5608,
                 959,
                 1119,
                 5_7702,
                 136,
                 186,
                 47,
                 1098,
                 2_9367,
                 47,
                 # 4426, # What fairseq tokenizes from "<unk>": "_<"
                 # 3678, # What fairseq tokenizes from "<unk>": "unk"
                 # 2740, # What fairseq tokenizes from "<unk>": ">"
                 3,  # What we tokenize from "<unk>": "<unk>"
                 6,  # Residue from the tokenization: an extra sentencepiece underline
                 4,
                 6044,
                 237,
                 6284,
                 5_0901,
                 528,
                 31,
                 90,
                 34,
                 927,
                 2,
             ]
             # xlmr = torch.hub.load('pytorch/fairseq', 'xlmr.base')  # xlmr.large has same tokenizer
             # xlmr.eval()
             # xlmr.encode(symbols)

             self.assertListEqual(lowercase_     ,  self.big_tokenizer.encode(lowercase_					)					)






      @slow
      def 			lowerCamelCase			(   self		:	Union[str, Any]					)   ->		Optional[int]:
             """simple docstring"""




             _lowerCamelCase			:						List[Any]            ={'input_ids': [[0, 1_1062, 8_2772, 7, 15, 8_2772, 538, 5_1529, 237, 1_7198, 1290, 206, 9, 21_5175, 1314, 136, 1_7198, 1290, 206, 9, 5_6359, 42, 12_2009, 9, 1_6466, 16, 8_7344, 4537, 9, 4717, 7_8381, 6, 15_9958, 7, 15, 2_4480, 618, 4, 527, 2_2693, 5428, 4, 2777, 2_4480, 9874, 4, 4_3523, 594, 4, 803, 1_8392, 3_3189, 18, 4, 4_3523, 2_4447, 1_2399, 100, 2_4955, 8_3658, 9626, 14_4057, 15, 839, 2_2335, 16, 136, 2_4955, 8_3658, 8_3479, 15, 3_9102, 724, 16, 678, 645, 2789, 1328, 4589, 42, 12_2009, 11_5774, 23, 805, 1328, 4_6876, 7, 136, 5_3894, 1940, 4_2227, 4_1159, 1_7721, 823, 425, 4, 2_7512, 9_8722, 206, 136, 5531, 4970, 919, 1_7336, 5, 2], [0, 2_0080, 618, 83, 8_2775, 47, 479, 9, 1517, 73, 5_3894, 333, 8_0581, 11_0117, 1_8811, 5256, 1295, 51, 15_2526, 297, 7986, 390, 12_4416, 538, 3_5431, 214, 98, 1_5044, 2_5737, 136, 7108, 4_3701, 23, 756, 13_5355, 7, 5, 2, 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, 581, 6_3773, 11_9455, 6, 14_7797, 8_8203, 7, 645, 70, 21, 3285, 1_0269, 5, 2, 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]], '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, 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], [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]]}  # noqa: E501
             # fmt: on

             self.tokenizer_integration_test_util(
                 expected_encoding=lowercase_     ,  model_name='xlm-roberta-base'     ,  revision='d9d8a8ea5eb94b1c6654ae9249df7793cd2933d3'     ,  )


