


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__							:  str      =XLMRobertaTokenizer
      UpperCamelCase__							:  List[Any]      =XLMRobertaTokenizerFast
      UpperCamelCase__							:  Optional[int]      =True
      UpperCamelCase__							:  str      =True






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




             super().setUp()

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






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




             _lowerCamelCase       :		int		='<pad>'
             _lowerCamelCase       :		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        lowerCamelCase       (					self						:     Dict )					->						Any:
             """simple docstring"""




             _lowerCamelCase       :		Union[str, Any]		=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						:     Dict )					->						Tuple:
             """simple docstring"""




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






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




             _lowerCamelCase       :		str		=XLMRobertaTokenizer(lowercase_			,   keep_accents=lowercase_ )

             _lowerCamelCase       :		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       :		List[str]		=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       :		List[str]		=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[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        lowerCamelCase       (					self						:     int )					->						str:
             """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[Any]		=(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       :		Dict		=self.rust_tokenizer_class.from_pretrained(lowercase_			,   **lowercase_ )
                           _lowerCamelCase       :		Optional[Any]		=self.tokenizer_class.from_pretrained(lowercase_			,   **lowercase_ )

                           _lowerCamelCase       :		List[str]		=tempfile.mkdtemp()

                           _lowerCamelCase       :		str		=tokenizer_r.save_pretrained(lowercase_ )
                           _lowerCamelCase       :		Union[str, Any]		=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[int]		=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       :		Tuple		=tempfile.mkdtemp()

                           _lowerCamelCase       :		Optional[int]		=tokenizer_r.save_pretrained(lowercase_			,   legacy_format=lowercase_ )
                           _lowerCamelCase       :		Optional[int]		=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       :		Union[str, Any]		=tokenizer_r.from_pretrained(lowercase_ )
                           _lowerCamelCase       :		Optional[int]		=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       :		Union[str, Any]		=tempfile.mkdtemp()

                           _lowerCamelCase       :		List[Any]		=tokenizer_r.save_pretrained(lowercase_			,   legacy_format=lowercase_ )
                           _lowerCamelCase       :		Tuple		=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       :		Union[str, 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_ )






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




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






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




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






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




             if not self.test_rust_tokenizer:
                    return

             _lowerCamelCase       :		List[Any]		=self.get_tokenizer()
             _lowerCamelCase       :		Union[str, Any]		=self.get_rust_tokenizer()

             _lowerCamelCase       :		Union[str, Any]		='I was born in 92000, and this is falsé.'

             _lowerCamelCase       :		Optional[int]		=tokenizer.tokenize(lowercase_ )
             _lowerCamelCase       :		int		=rust_tokenizer.tokenize(lowercase_ )
             self.assertListEqual(lowercase_			,   lowercase_ )

             _lowerCamelCase       :		Tuple		=tokenizer.encode(lowercase_			,   add_special_tokens=lowercase_ )
             _lowerCamelCase       :		Tuple		=rust_tokenizer.encode(lowercase_			,   add_special_tokens=lowercase_ )
             self.assertListEqual(lowercase_			,   lowercase_ )

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






      @slow
      def        lowerCamelCase       (					self						:     str )					->						Tuple:
             """simple docstring"""




             _lowerCamelCase       :		Any		='Hello World!'
             _lowerCamelCase       :		List[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						:     Tuple )					->						Dict:
             """simple docstring"""




             _lowerCamelCase       :		Dict		=(
                 '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       :		Tuple		=[
                 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						:     Any )					->						Union[str, Any]:
             """simple docstring"""




             _lowerCamelCase       :		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'			,   )






import unittest

from transformers.models.xlm_prophetnet.tokenization_xlm_prophetnet import SPIECE_UNDERLINE, XLMProphetNetTokenizer
from transformers.testing_utils import get_tests_dir, require_sentencepiece, slow
from transformers.utils import cached_property

from ...test_tokenization_common import TokenizerTesterMixin


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




@require_sentencepiece
class A  (   UpperCamelCase_    ,							unittest.TestCase     ):
      UpperCamelCase__							:  str      =XLMProphetNetTokenizer
      UpperCamelCase__							:  Any      =False
      UpperCamelCase__							:  Optional[Any]      =True






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




             super().setUp()

             # We have a SentencePiece fixture for testing
             _lowerCamelCase       :		Union[str, Any]		=XLMProphetNetTokenizer(lowercase_			,   keep_accents=lowercase_ )
             tokenizer.save_pretrained(self.tmpdirname )






      def        lowerCamelCase       (					self						:     int )					->						List[str]:
             """simple docstring"""




             _lowerCamelCase       :		Tuple		='[PAD]'
             _lowerCamelCase       :		Dict		=0

             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						:     Optional[Any] )					->						int:
             """simple docstring"""




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

             self.assertEqual(vocab_keys[0]			,   '[PAD]' )
             self.assertEqual(vocab_keys[1]			,   '[CLS]' )
             self.assertEqual(vocab_keys[-1]			,   'j' )
             self.assertEqual(len(lowercase_ )			,   1012 )






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




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






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




             _lowerCamelCase       :		List[Any]		=XLMProphetNetTokenizer(lowercase_			,   keep_accents=lowercase_ )

             _lowerCamelCase       :		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       :		Dict		=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       :		Union[str, Any]		=tokenizer.convert_tokens_to_ids(lowercase_ )
             self.assertListEqual(
                 lowercase_			,   [
                     value + tokenizer.fairseq_offset
                     for value in [8, 21, 84, 55, 24, 19, 7, -9, 602, 347, 347, 347, 3, 12, 66, 46, 72, 80, 6, -9, 4]
                 ]			,   )

             _lowerCamelCase       :		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]',
                     '.',
                 ]			,   )






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




             return XLMProphetNetTokenizer.from_pretrained('microsoft/xprophetnet-large-wiki100-cased' )






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




             _lowerCamelCase       :		Optional[int]		='Hello World!'
             _lowerCamelCase       :		Optional[int]		=[3_5389, 6672, 49, 2]
             self.assertListEqual(lowercase_			,   self.big_tokenizer.encode(lowercase_ ) )






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




             _lowerCamelCase       :		Dict		={'input_ids': [[1_1073, 8_2783, 18, 26, 8_2783, 549, 5_1540, 248, 1_7209, 1301, 217, 20, 21_5186, 1325, 147, 1_7209, 1301, 217, 20, 5_6370, 53, 12_2020, 20, 1_6477, 27, 8_7355, 4548, 20, 4728, 7_8392, 17, 15_9969, 18, 26, 2_4491, 629, 15, 538, 2_2704, 5439, 15, 2788, 2_4491, 9885, 15, 4_3534, 605, 15, 814, 1_8403, 3_3200, 29, 15, 4_3534, 2_4458, 1_2410, 111, 2_4966, 8_3669, 9637, 14_4068, 26, 850, 2_2346, 27, 147, 2_4966, 8_3669, 8_3490, 26, 3_9113, 735, 27, 689, 656, 2800, 1339, 4600, 53, 12_2020, 11_5785, 34, 816, 1339, 4_6887, 18, 147, 5_3905, 1951, 4_2238, 4_1170, 1_7732, 834, 436, 15, 2_7523, 9_8733, 217, 147, 5542, 4981, 930, 1_7347, 16, 2], [2_0091, 629, 94, 8_2786, 58, 490, 20, 1528, 84, 5_3905, 344, 8_0592, 11_0128, 1_8822, 5267, 1306, 62, 15_2537, 308, 7997, 401, 12_4427, 549, 3_5442, 225, 109, 1_5055, 2_5748, 147, 7119, 4_3712, 34, 767, 13_5366, 18, 16, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [592, 6_3784, 11_9466, 17, 14_7808, 8_8214, 18, 656, 81, 32, 3296, 1_0280, 16, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], '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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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='microsoft/xprophetnet-large-wiki100-cased'			,   revision='1acad1643ddd54a44df6a1b797ada8373685d90e'			,   )


