



'''simple docstring'''

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

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import is_sentencepiece_available, logging


if is_sentencepiece_available():
	from .tokenization_pegasus import PegasusTokenizer
else:
	a							   =				None


a							   =				logging.get_logger(__name__)


a							   =				'▁'

a							   =				{'vocab_file': 'spiece.model', 'tokenizer_file': 'tokenizer.json'}

a							   =				{
    'vocab_file': {'google/pegasus-xsum': 'https://huggingface.co/google/pegasus-xsum/resolve/main/spiece.model'},
    'tokenizer_file': {
        'google/pegasus-xsum': 'https://huggingface.co/google/pegasus-xsum/resolve/main/tokenizer.json'
    },
}

a							   =				{
    'google/pegasus-xsum': 512,
}






class 						a_		(     snake_case    ):
							UpperCAmelCase			:		List[Any]        =				VOCAB_FILES_NAMES
							UpperCAmelCase			:		Optional[int]        =				PRETRAINED_VOCAB_FILES_MAP
							UpperCAmelCase			:		Optional[Any]        =				PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
							UpperCAmelCase			:		Any        =				PegasusTokenizer
							UpperCAmelCase			:		int        =				["""input_ids""", """attention_mask"""]


							def __init__(				self   :						Union[str, Any]      ,						a_   :						Any=None      ,						a_   :						Any=None      ,						a_   :						int="<pad>"      ,						a_   :						Union[str, Any]="</s>"      ,						a_   :						Any="<unk>"      ,						a_   :						Optional[Any]="<mask_2>"      ,						a_   :						List[Any]="<mask_1>"      ,						a_   :						int=None      ,						a_   :						Optional[int]=1_0_3      ,						**a_   :						str      ,						)			->					List[str]:
										snake_case:    List[str]      							=offset

										if additional_special_tokens is not None:
													if not isinstance(a_      ,						a_			):
																raise TypeError(
																    F'''additional_special_tokens should be of type {type(a_			)}, but is'''
																    F''' {type(a_			)}'''			)

													snake_case:    List[str]      							=(
													    ([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(a_			)      ,						self.offset - 1			)
													]

													if len(set(a_			)			) != len(a_			):
																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}.'''			)
													snake_case:    Optional[Any]      							=additional_special_tokens_extended
										else:
													snake_case:    Optional[Any]      							=[mask_token_sent] if mask_token_sent is not None else []
													additional_special_tokens += [F'''<unk_{i}>''' for i in range(2      ,						self.offset			)]

										super().__init__(
										    a_      ,						tokenizer_file=a_      ,						pad_token=a_      ,						eos_token=a_      ,						unk_token=a_      ,						mask_token=a_      ,						mask_token_sent=a_      ,						offset=a_      ,						additional_special_tokens=a_      ,						**a_      ,						)
										snake_case:    str      							=vocab_file
										snake_case:    List[str]      							=False if not self.vocab_file else True


							def    UpperCamelCase     (				self   :						Union[str, Any]      ,						a_   :						str			)			->					Any:
										snake_case:    Tuple      							=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

										if all_special_ids != set(range(len(self.additional_special_tokens			) + 3			)			):
													raise ValueError(
													    'There should be 3 special tokens: mask_token, pad_token, and eos_token +'
													    F''' {len(self.additional_special_tokens			)} additional_special_tokens, but got {all_special_ids}'''			)

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


							def    UpperCamelCase     (				self   :						List[str]      ,						a_   :						List      ,						a_   :						Optional[List] = None      ,						a_   :						bool = False			)			->					List[int]:
										if already_has_special_tokens:
													return self._special_token_mask(a_			)
										elif token_ids_a is None:
													return self._special_token_mask(a_			) + [1]
										else:
													return self._special_token_mask(token_ids_a + token_ids_a			) + [1]


							def    UpperCamelCase     (				self   :						List[Any]      ,						a_   :						Dict      ,						a_   :						List[str]=None			)			->					List[int]:
										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    UpperCamelCase     (				self   :						Optional[Any]      ,						a_   :						str      ,						a_   :						Optional[str] = None			)			->					Tuple[str]:
										if not self.can_save_slow_tokenizer:
													raise ValueError(
													    'Your fast tokenizer does not have the necessary information to save the vocabulary for a slow '
													    'tokenizer.'			)

										if not os.path.isdir(a_			):
													logger.error(F'''Vocabulary path ({save_directory}) should be a directory'''			)
													return
										snake_case:    Union[str, Any]      							=os.path.join(
										    a_      ,						(filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['vocab_file']			)

										if os.path.abspath(self.vocab_file			) != os.path.abspath(a_			):
													copyfile(self.vocab_file      ,						a_			)

										return (out_vocab_file,)









'''simple docstring'''

import unittest

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

from ...test_tokenization_common import TokenizerTesterMixin


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






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


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

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


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

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


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

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


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


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

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

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

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

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


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


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


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

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

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

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




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

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




