




'''simple docstring'''



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


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






@require_sentencepiece
class 							_a				(			SCREAMING_SNAKE_CASE ,      unittest.TestCase ):





       '''simple docstring'''






       A						:				Optional[int]        =						XLMProphetNetTokenizer
       A						:				List[str]        =						False
       A						:				Union[str, Any]        =						True







       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             super().setUp()

             # We have a SentencePiece fixture for testing
             SCREAMING_SNAKE_CASE   :      List[str]    					=						XLMProphetNetTokenizer(A,							keep_accents=A  )
             tokenizer.save_pretrained(self.tmpdirname  )







       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      Dict    					=						'[PAD]'
             SCREAMING_SNAKE_CASE   :      Any    					=						0

             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  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      Tuple    					=						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(A  ),							1_012  )







       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             self.assertEqual(self.get_tokenizer().vocab_size,							1_012  )







       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      str    					=						XLMProphetNetTokenizer(A,							keep_accents=A  )

             SCREAMING_SNAKE_CASE   :      Tuple    					=						tokenizer.tokenize('This is a test'  )
             self.assertListEqual(A,							['▁This', '▁is', '▁a', '▁t', 'est']  )

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

             SCREAMING_SNAKE_CASE   :      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',
                     's',
                     'é',
                     '.',
                 ],							)
             SCREAMING_SNAKE_CASE   :      Tuple    					=						tokenizer.convert_tokens_to_ids(A  )
             self.assertListEqual(
                 A,							[
                     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]
                 ],							)

             SCREAMING_SNAKE_CASE   :      Dict    					=						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]',
                     '.',
                 ],							)







       @cached_property
       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







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







       @slow
       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      Optional[int]    					=						'Hello World!'
             SCREAMING_SNAKE_CASE   :      int    					=						[35_389, 6_672, 49, 2]
             self.assertListEqual(A,							self.big_tokenizer.encode(A  )  )







       @slow
       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      Tuple    					=						{'input_ids': [[11_073, 82_783, 18, 26, 82_783, 549, 51_540, 248, 17_209, 1_301, 217, 20, 215_186, 1_325, 147, 17_209, 1_301, 217, 20, 56_370, 53, 122_020, 20, 16_477, 27, 87_355, 4_548, 20, 4_728, 78_392, 17, 159_969, 18, 26, 24_491, 629, 15, 538, 22_704, 5_439, 15, 2_788, 24_491, 9_885, 15, 43_534, 605, 15, 814, 18_403, 33_200, 29, 15, 43_534, 24_458, 12_410, 111, 24_966, 83_669, 9_637, 144_068, 26, 850, 22_346, 27, 147, 24_966, 83_669, 83_490, 26, 39_113, 735, 27, 689, 656, 2_800, 1_339, 4_600, 53, 122_020, 115_785, 34, 816, 1_339, 46_887, 18, 147, 53_905, 1_951, 42_238, 41_170, 17_732, 834, 436, 15, 27_523, 98_733, 217, 147, 5_542, 4_981, 930, 17_347, 16, 2], [20_091, 629, 94, 82_786, 58, 490, 20, 1_528, 84, 53_905, 344, 80_592, 110_128, 18_822, 5_267, 1_306, 62, 152_537, 308, 7_997, 401, 124_427, 549, 35_442, 225, 109, 15_055, 25_748, 147, 7_119, 43_712, 34, 767, 135_366, 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, 63_784, 119_466, 17, 147_808, 88_214, 18, 656, 81, 32, 3_296, 10_280, 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=A,							model_name='microsoft/xprophetnet-large-wiki100-cased',							revision='1acad1643ddd54a44df6a1b797ada8373685d90e',							)










import os
from shutil import copyfile
from typing import Any, Dict, List, Optional, Tuple

import sentencepiece as spm

from ...tokenization_utils import PreTrainedTokenizer
from ...utils import logging


__a   :							List[str]						= "▁"

__a   :							int						= {"vocab_file": "spiece.model"}

__a   :							Any						= {
    "vocab_file": {"google/pegasus-xsum": "https://huggingface.co/google/pegasus-xsum/resolve/main/spiece.model"}
}

__a   :							Any						= {
    "google/pegasus-xsum": 512,
}


__a   :							Union[str, Any]						= logging.get_logger(__name__)


class    __lowercase   (						lowercase_	):







     '''simple docstring'''
     SCREAMING_SNAKE_CASE     =					VOCAB_FILES_NAMES

     SCREAMING_SNAKE_CASE     =					VOCAB_FILES_NAMES
     SCREAMING_SNAKE_CASE     =					PRETRAINED_VOCAB_FILES_MAP
     SCREAMING_SNAKE_CASE     =					PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
     SCREAMING_SNAKE_CASE     =					["input_ids", "attention_mask"]




     def __init__(					self							:      List[str]			,						UpperCamelCase_							:      int			,						UpperCamelCase_							:      Dict="<pad>"			,						UpperCamelCase_							:      Dict="</s>"			,						UpperCamelCase_							:      Optional[Any]="<unk>"			,						UpperCamelCase_							:      List[Any]="<mask_2>"			,						UpperCamelCase_							:      List[Any]="<mask_1>"			,						UpperCamelCase_							:      str=None			,						UpperCamelCase_							:      Dict=103			,						UpperCamelCase_							:      Optional[Dict[str, Any]] = None			,						**UpperCamelCase_							:      int			,						):


         """simple docstring"""



         __A       =						offset
         if additional_special_tokens is not None:
             if not isinstance(UpperCamelCase_			,						UpperCamelCase_					):
                 raise TypeError(
                     F"additional_special_tokens should be of type {type(UpperCamelCase_					)}, but is"
                     F" {type(UpperCamelCase_					)}"					)

             __A       =						(
                 ([mask_token_sent] + additional_special_tokens)
                 if mask_token_sent not in additional_special_tokens and mask_token_sent is not None
                 else additional_special_tokens
             )
             # fill additional tokens with ..., <unk_token_102> in case not all additional tokens are already taken
             additional_special_tokens_extended += [
                 F"<unk_{i}>" for i in range(len(UpperCamelCase_					)			,						self.offset - 1					)
             ]

             if len(set(UpperCamelCase_					)					) != len(UpperCamelCase_					):
                 raise ValueError(
                     """Please make sure that the provided additional_special_tokens do not contain an incorrectly"""
                     F" shifted list of <unk_x> tokens. Found {additional_special_tokens_extended}."					)
             __A       =						additional_special_tokens_extended
         else:
             __A       =						[mask_token_sent] if mask_token_sent is not None else []
             additional_special_tokens += [F"<unk_{i}>" for i in range(2			,						self.offset					)]

         __A       =						{} if sp_model_kwargs is None else sp_model_kwargs

         super().__init__(
             eos_token=UpperCamelCase_			,						unk_token=UpperCamelCase_			,						mask_token=UpperCamelCase_			,						pad_token=UpperCamelCase_			,						mask_token_sent=UpperCamelCase_			,						offset=UpperCamelCase_			,						additional_special_tokens=UpperCamelCase_			,						sp_model_kwargs=self.sp_model_kwargs			,						**UpperCamelCase_			,						)
         __A       =						mask_token_sent
         __A       =						vocab_file
         __A       =						spm.SentencePieceProcessor(**self.sp_model_kwargs					)
         self.sp_model.Load(UpperCamelCase_					)

         # add special tokens to encoder dict
         __A       =						{
             0: self.pad_token,
             1: self.eos_token,
         }

         if self.mask_token_sent is not None:
             self.encoder.update(
                 {
                     2: self.mask_token_sent,
                     3: self.mask_token,
                 }					)

         if self.offset > 0:
             # entries 2-104 are only used for pretraining and called <mask_1>, <mask_2>, unk_2, ...unk_102
             # mask_token_sent is already added to list -> so start at 1
             self.encoder.update({i + 3: additional_special_tokens[i] for i in range(1			,						self.offset - 1					)}					)

         __A       =						{v: k for k, v in self.encoder.items()}




     @property
     def 		lowerCAmelCase_  (					self							:      Any					):


         """simple docstring"""



         return len(self.sp_model					) + self.offset




     def 		lowerCAmelCase_  (					self							:      Any					):


         """simple docstring"""



         __A       =						{self.convert_ids_to_tokens(UpperCamelCase_					): i for i in range(self.vocab_size					)}
         vocab.update(self.added_tokens_encoder					)
         return vocab




     def __getstate__(					self							:      Tuple					):


         """simple docstring"""



         __A       =						self.__dict__.copy()
         __A       =						None
         return state




     def __setstate__(					self							:      Tuple			,						UpperCamelCase_							:      Dict					):


         """simple docstring"""



         __A       =						d

         # for backward compatibility
         if not hasattr(self			,						"""sp_model_kwargs"""					):
             __A       =						{}

         __A       =						spm.SentencePieceProcessor(**self.sp_model_kwargs					)
         self.sp_model.Load(self.vocab_file					)




     def 		lowerCAmelCase_  (					self							:      Tuple			,						UpperCamelCase_							:      str					):


         """simple docstring"""



         return self.sp_model.encode(UpperCamelCase_			,						out_type=UpperCamelCase_					)




     def 		lowerCAmelCase_  (					self							:      str			,						UpperCamelCase_							:      str					):


         """simple docstring"""



         if token in self.decoder:
             return self.decoder[token]
         elif token in self.added_tokens_decoder:
             return self.added_tokens_decoder[token]
         __A       =						self.sp_model.piece_to_id(UpperCamelCase_					)
         return sp_id + self.offset




     def 		lowerCAmelCase_  (					self							:      int			,						UpperCamelCase_							:      int					):


         """simple docstring"""



         if index in self.encoder:
             return self.encoder[index]
         elif index in self.added_tokens_encoder:
             return self.added_tokens_encoder[index]
         else:
             __A       =						self.sp_model.IdToPiece(index - self.offset					)
         return token




     def 		lowerCAmelCase_  (					self							:      Optional[int]			,						UpperCamelCase_							:      List[str]					):


         """simple docstring"""



         __A       =						[]
         __A       =						""""""
         for token in tokens:
             # make sure that special tokens are not decoded using sentencepiece model
             if token in self.all_special_tokens:
                 out_string += self.sp_model.decode(UpperCamelCase_					) + token
                 __A       =						[]
             else:
                 current_sub_tokens.append(UpperCamelCase_					)
         out_string += self.sp_model.decode(UpperCamelCase_					)
         return out_string.strip()




     def 		lowerCAmelCase_  (					self							:      Any			,						UpperCamelCase_							:      List[Any]=False					):


         """simple docstring"""



         return 1




     def 		lowerCAmelCase_  (					self							:      Optional[int]			,						UpperCamelCase_							:      Tuple					):


         """simple docstring"""



         __A       =						set(self.all_special_ids					)  # call it once instead of inside list comp
         all_special_ids.remove(self.unk_token_id					)  # <unk> is only sometimes special

         return [1 if x in all_special_ids else 0 for x in seq]




     def 		lowerCAmelCase_  (					self							:      int			,						UpperCamelCase_							:      List			,						UpperCamelCase_							:      Optional[List] = None			,						UpperCamelCase_							:      bool = False					):


         """simple docstring"""



         if already_has_special_tokens:
             return self._special_token_mask(UpperCamelCase_					)
         elif token_ids_a is None:
             return self._special_token_mask(UpperCamelCase_					) + [1]
         else:
             return self._special_token_mask(token_ids_a + token_ids_a					) + [1]




     def 		lowerCAmelCase_  (					self							:      List[Any]			,						UpperCamelCase_							:      str			,						UpperCamelCase_							:      Optional[Any]=None					):


         """simple docstring"""



         if token_ids_a is None:
             return token_ids_a + [self.eos_token_id]
         # We don't expect to process pairs, but leave the pair logic for API consistency
         return token_ids_a + token_ids_a + [self.eos_token_id]





     def 		lowerCAmelCase_  (					self							:      List[Any]			,						UpperCamelCase_							:      str			,						UpperCamelCase_							:      Optional[str] = None					):


         """simple docstring"""



         if not os.path.isdir(UpperCamelCase_					):
             logger.error(F"Vocabulary path ({save_directory}) should be a directory"					)
             return
         __A       =						os.path.join(
             UpperCamelCase_			,						(filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab_file"""]					)

         if os.path.abspath(self.vocab_file					) != os.path.abspath(UpperCamelCase_					) and os.path.isfile(self.vocab_file					):
             copyfile(self.vocab_file			,						UpperCamelCase_					)
         elif not os.path.isfile(self.vocab_file					):
             with open(UpperCamelCase_			,						"""wb"""					) as fi:
                 __A       =						self.sp_model.serialized_model_proto()
                 fi.write(UpperCamelCase_					)

         return (out_vocab_file,)




