




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

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


if is_sentencepiece_available():
						from .tokenization_big_bird import BigBirdTokenizer
else:
						UpperCamelCase__ :   List[Any]						=							None

UpperCamelCase__ :   Union[str, Any]						=							logging.get_logger(__name__)
UpperCamelCase__ :   Dict						=							{'''vocab_file''': '''spiece.model''', '''tokenizer_file''': '''tokenizer.json'''}

UpperCamelCase__ :   int						=							{
    '''vocab_file''': {
        '''google/bigbird-roberta-base''': '''https://huggingface.co/google/bigbird-roberta-base/resolve/main/spiece.model''',
        '''google/bigbird-roberta-large''': (
            '''https://huggingface.co/google/bigbird-roberta-large/resolve/main/spiece.model'''
        ),
        '''google/bigbird-base-trivia-itc''': (
            '''https://huggingface.co/google/bigbird-base-trivia-itc/resolve/main/spiece.model'''
        ),
    },
    '''tokenizer_file''': {
        '''google/bigbird-roberta-base''': (
            '''https://huggingface.co/google/bigbird-roberta-base/resolve/main/tokenizer.json'''
        ),
        '''google/bigbird-roberta-large''': (
            '''https://huggingface.co/google/bigbird-roberta-large/resolve/main/tokenizer.json'''
        ),
        '''google/bigbird-base-trivia-itc''': (
            '''https://huggingface.co/google/bigbird-base-trivia-itc/resolve/main/tokenizer.json'''
        ),
    },
}

UpperCamelCase__ :   List[Any]						=							{
    '''google/bigbird-roberta-base''': 40_96,
    '''google/bigbird-roberta-large''': 40_96,
    '''google/bigbird-base-trivia-itc''': 40_96,
}


UpperCamelCase__ :   Union[str, Any]						=							'''▁'''







class 				lowerCAmelCase_       (					lowerCamelCase_							):
				__a     :       Union[str, Any]						=     VOCAB_FILES_NAMES
				__a     :       Any						=     PRETRAINED_VOCAB_FILES_MAP
				__a     :       int						=     PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
				__a     :       Any						=     BigBirdTokenizer
				__a     :       str						=     ["input_ids", "attention_mask"]
				__a     :       List[int]						=     []






				def __init__(			self      ,snake_case__=None      ,snake_case__=None      ,snake_case__="<unk>"      ,snake_case__="<s>"      ,snake_case__="</s>"      ,snake_case__="<pad>"      ,snake_case__="[SEP]"      ,snake_case__="[MASK]"      ,snake_case__="[CLS]"      ,**snake_case__      ,):
							SCREAMING_SNAKE_CASE_   : Tuple					  =      AddedToken(snake_case__      ,lstrip=snake_case__      ,rstrip=snake_case__ ) if isinstance(snake_case__      ,snake_case__ ) else bos_token
							SCREAMING_SNAKE_CASE_   : Union[str, Any]					  =      AddedToken(snake_case__      ,lstrip=snake_case__      ,rstrip=snake_case__ ) if isinstance(snake_case__      ,snake_case__ ) else eos_token
							SCREAMING_SNAKE_CASE_   : List[Any]					  =      AddedToken(snake_case__      ,lstrip=snake_case__      ,rstrip=snake_case__ ) if isinstance(snake_case__      ,snake_case__ ) else unk_token
							SCREAMING_SNAKE_CASE_   : str					  =      AddedToken(snake_case__      ,lstrip=snake_case__      ,rstrip=snake_case__ ) if isinstance(snake_case__      ,snake_case__ ) else pad_token
							SCREAMING_SNAKE_CASE_   : int					  =      AddedToken(snake_case__      ,lstrip=snake_case__      ,rstrip=snake_case__ ) if isinstance(snake_case__      ,snake_case__ ) else cls_token
							SCREAMING_SNAKE_CASE_   : Optional[int]					  =      AddedToken(snake_case__      ,lstrip=snake_case__      ,rstrip=snake_case__ ) if isinstance(snake_case__      ,snake_case__ ) else sep_token

							# Mask token behave like a normal word, i.e. include the space before it
							SCREAMING_SNAKE_CASE_   : List[Any]					  =      AddedToken(snake_case__      ,lstrip=snake_case__      ,rstrip=snake_case__ ) if isinstance(snake_case__      ,snake_case__ ) else mask_token

							super().__init__(
							    snake_case__      ,tokenizer_file=snake_case__      ,bos_token=snake_case__      ,eos_token=snake_case__      ,unk_token=snake_case__      ,sep_token=snake_case__      ,pad_token=snake_case__      ,cls_token=snake_case__      ,mask_token=snake_case__      ,**snake_case__      ,)

							SCREAMING_SNAKE_CASE_   : Optional[Any]					  =      vocab_file
							SCREAMING_SNAKE_CASE_   : int					  =      False if not self.vocab_file else True






				def 		snake_case	(			self      ,snake_case__      ,snake_case__ = None ):
							SCREAMING_SNAKE_CASE_   : Dict					  =      [self.sep_token_id]
							SCREAMING_SNAKE_CASE_   : Any					  =      [self.cls_token_id]
							if token_ids_a is None:
										return cls + token_ids_a + sep
							return cls + token_ids_a + sep + token_ids_a + sep






				def 		snake_case	(			self      ,snake_case__      ,snake_case__ = None      ,snake_case__ = False ):

							if already_has_special_tokens:
										if token_ids_a is not None:
													raise ValueError(
													    'You should not supply a second sequence if the provided sequence of '
													    'ids is already formatted with special tokens for the model.' )
										return [1 if x in [self.sep_token_id, self.cls_token_id] else 0 for x in token_ids_a]

							if token_ids_a is None:
										return [1] + ([0] * len(snake_case__ )) + [1]
							return [1] + ([0] * len(snake_case__ )) + [1] + ([0] * len(snake_case__ )) + [1]






				def 		snake_case	(			self      ,snake_case__      ,snake_case__ = None ):
							SCREAMING_SNAKE_CASE_   : Union[str, Any]					  =      [self.sep_token_id]
							SCREAMING_SNAKE_CASE_   : str					  =      [self.cls_token_id]

							if token_ids_a is None:
										return len(cls + token_ids_a + sep ) * [0]
							return len(cls + token_ids_a + sep ) * [0] + len(token_ids_a + sep ) * [1]






				def 		snake_case	(			self      ,snake_case__      ,snake_case__ = None ):
							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(snake_case__ ):
										logger.error(F'Vocabulary path ({save_directory}) should be a directory' )
										return
							SCREAMING_SNAKE_CASE_   : str					  =      os.path.join(
							    snake_case__      ,(filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['vocab_file'] )

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

							return (out_vocab_file,)








import json
import os
import unittest

from transformers.models.gptsan_japanese.tokenization_gptsan_japanese import (
    VOCAB_FILES_NAMES,
    GPTSanJapaneseTokenizer,
)
from transformers.testing_utils import require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin



@require_tokenizers
class        lowerCAmelCase__					(  _lowerCamelCase ,				unittest.TestCase       ):
				A_   :     Dict								=     GPTSanJapaneseTokenizer
				A_   :     Optional[int]								=     False
				A_   :     List[str]								=     {'do_clean_text': False, 'add_prefix_space': False}


				def __UpperCamelCase						(							self      :  Tuple       )		->     Any:
											super().setUp()

											# fmt: off
											A      						=    ['こん', 'こんに', 'にちは', 'ばんは', '世界,㔺界', '、', '。', '<BR>', '<SP>', '<TAB>', '<URL>', '<EMAIL>', '<TEL>', '<DATE>', '<PRICE>', '<BLOCK>', '<KIGOU>', '<U2000U2BFF>', '<|emoji1|>', '<unk>', '<|bagoftoken|>', '<|endoftext|>']
											# fmt: on
											A      						=    {'emoji': {'\ud83d\ude00': '<|emoji1|>'}, 'emoji_inv': {'<|emoji1|>': '\ud83d\ude00'}}  # 😀
											A      						=    {'unk_token': '<unk>'}

											A      						=    os.path.join(self.tmpdirname						, VOCAB_FILES_NAMES['vocab_file']       )
											A      						=    os.path.join(self.tmpdirname						, VOCAB_FILES_NAMES['emoji_file']       )
											with open(self.vocab_file						, 'w'						, encoding='utf-8'       ) as vocab_writer:
																		vocab_writer.write(''.join([x + '\n' for x in vocab_tokens]       )       )
											with open(self.emoji_file						, 'w'       ) as emoji_writer:
																		emoji_writer.write(json.dumps(__UpperCamelCase       )       )


				def __UpperCamelCase						(							self      :  Any						, **__UpperCamelCase      :  Any       )		->     Tuple:
											kwargs.update(self.special_tokens_map       )
											return GPTSanJapaneseTokenizer.from_pretrained(self.tmpdirname						, **__UpperCamelCase       )


				def __UpperCamelCase						(							self      :  str						, __UpperCamelCase      :  Dict       )		->     List[str]:
											A      						=    'こんにちは、世界。 \nこんばんは、㔺界。😀'
											A      						=    'こんにちは、世界。 \nこんばんは、世界。😀'
											return input_text, output_text


				def __UpperCamelCase						(							self      :  str						, __UpperCamelCase      :  Optional[Any]       )		->     List[str]:
											A						,   A      						=    self.get_input_output_texts(__UpperCamelCase       )
											A      						=    tokenizer.encode(__UpperCamelCase						, add_special_tokens=__UpperCamelCase       )
											A      						=    tokenizer.decode(__UpperCamelCase						, clean_up_tokenization_spaces=__UpperCamelCase       )
											return text, ids


				def __UpperCamelCase						(							self      :  Any       )		->     int:
											pass  # TODO add if relevant


				def __UpperCamelCase						(							self      :  List[str]       )		->     Tuple:
											pass  # TODO add if relevant


				def __UpperCamelCase						(							self      :  List[str]       )		->     List[Any]:
											pass  # TODO add if relevant


				def __UpperCamelCase						(							self      :  List[str]       )		->     int:
											A      						=    self.get_tokenizer()

											# Testing tokenization
											A      						=    'こんにちは、世界。　こんばんは、㔺界。'
											A      						=    ['こん', 'にちは', '、', '世界', '。', '<SP>', 'こん', 'ばんは', '、', '㔺界', '。']
											A      						=    tokenizer.tokenize(__UpperCamelCase       )
											self.assertListEqual(__UpperCamelCase						, __UpperCamelCase       )

											# Testing conversion to ids without special tokens
											A      						=    [0, 2, 5, 4, 6, 8, 0, 3, 5, 4, 6]
											A      						=    tokenizer.convert_tokens_to_ids(__UpperCamelCase       )
											self.assertListEqual(__UpperCamelCase						, __UpperCamelCase       )

											# Testing conversion to ids with special tokens
											A      						=    tokens + [tokenizer.unk_token]
											A      						=    [0, 2, 5, 4, 6, 8, 0, 3, 5, 4, 6, 19]
											A      						=    tokenizer.convert_tokens_to_ids(__UpperCamelCase       )
											self.assertListEqual(__UpperCamelCase						, __UpperCamelCase       )


				def __UpperCamelCase						(							self      :  Union[str, Any]       )		->     List[str]:
											A      						=    self.get_tokenizer()

											# Testing tokenization
											A      						=    'こんにちは、<|bagoftoken|>世界。こんばんは、<|bagoftoken|>㔺界。'
											A      						=    'こんにちは、、、、世界。こんばんは、、、、世界。'
											A      						=    tokenizer.encode(__UpperCamelCase       )
											A      						=    tokenizer.decode(__UpperCamelCase       )
											self.assertEqual(__UpperCamelCase						, __UpperCamelCase       )


				@slow
				def __UpperCamelCase						(							self      :  Union[str, Any]       )		->     str:
											A      						=    self.tokenizer_class.from_pretrained('Tanrei/GPTSAN-japanese'       )

											# Testing tokenization
											A      						=    'こんにちは、世界。'
											A      						=    'こんばんは、㔺界。😀'
											A      						=    'こんにちは、世界。こんばんは、世界。😀'
											A      						=    tokenizer.encode(prefix_text + input_text       )
											A      						=    tokenizer.encode(''						, prefix_text=prefix_text + input_text       )
											A      						=    tokenizer.encode(__UpperCamelCase						, prefix_text=__UpperCamelCase       )
											A      						=    tokenizer.decode(__UpperCamelCase       )
											A      						=    tokenizer.decode(__UpperCamelCase       )
											A      						=    tokenizer.decode(__UpperCamelCase       )
											self.assertEqual(__UpperCamelCase						, __UpperCamelCase       )
											self.assertEqual(__UpperCamelCase						, __UpperCamelCase       )
											self.assertEqual(__UpperCamelCase						, __UpperCamelCase       )


				@slow
				def __UpperCamelCase						(							self      :  Union[str, Any]       )		->     List[Any]:
											A      						=    self.tokenizer_class.from_pretrained('Tanrei/GPTSAN-japanese'       )

											# Testing tokenization
											A      						=    'こんにちは、世界。'
											A      						=    'こんばんは、㔺界。😀'

											A      						=    len(tokenizer.encode(__UpperCamelCase       )       ) - 2
											A      						=    len(tokenizer.encode(__UpperCamelCase       )       ) - 2

											A      						=    [1] + [0] * (len_prefix + len_text + 1)
											A      						=    [1] * (len_prefix + len_text + 1) + [0]
											A      						=    [1] + [1] * (len_prefix) + [0] * (len_text + 1)

											A      						=    tokenizer(prefix_text + input_text       ).token_type_ids
											A      						=    tokenizer(''						, prefix_text=prefix_text + input_text       ).token_type_ids
											A      						=    tokenizer(__UpperCamelCase						, prefix_text=__UpperCamelCase       ).token_type_ids
											self.assertListEqual(__UpperCamelCase						, __UpperCamelCase       )
											self.assertListEqual(__UpperCamelCase						, __UpperCamelCase       )
											self.assertListEqual(__UpperCamelCase						, __UpperCamelCase       )


				@slow
				def __UpperCamelCase						(							self      :  Any       )		->     str:
											A      						=    self.tokenizer_class.from_pretrained('Tanrei/GPTSAN-japanese'       )

											A      						=    tokenizer.encode('あンいワ'       )
											A      						=    tokenizer.encode(''						, prefix_text='あンいワ'       )
											A      						=    tokenizer.encode('いワ'						, prefix_text='あン'       )

											self.assertEqual(tokenizer.decode(__UpperCamelCase       )						, tokenizer.decode(__UpperCamelCase       )       )
											self.assertEqual(tokenizer.decode(__UpperCamelCase       )						, tokenizer.decode(__UpperCamelCase       )       )
											self.assertNotEqual(__UpperCamelCase						, __UpperCamelCase       )
											self.assertNotEqual(__UpperCamelCase						, __UpperCamelCase       )
											self.assertEqual(x_token_a[1]						, x_token_a[-1]       )  # SEG token
											self.assertEqual(x_token_a[1]						, x_token_a[3]       )  # SEG token


				@slow
				def __UpperCamelCase						(							self      :  Any       )		->     List[Any]:
											A      						=    self.tokenizer_class.from_pretrained('Tanrei/GPTSAN-japanese'       )

											A      						=    [['武田信玄', 'は、'], ['織田信長', 'の配下の、']]
											A      						=    tokenizer(__UpperCamelCase						, padding=__UpperCamelCase       )
											A      						=    tokenizer.batch_encode_plus(__UpperCamelCase						, padding=__UpperCamelCase       )

											# fmt: off
											A      						=    [[35_993, 8_640, 25_948, 35_998, 30_647, 35_675, 35_999, 35_999], [35_993, 10_382, 9_868, 35_998, 30_646, 9_459, 30_646, 35_675]]
											A      						=    [[1, 1, 1, 0, 0, 0, 0, 0], [1, 1, 1, 0, 0, 0, 0, 0]]
											A      						=    [[1, 1, 1, 1, 1, 1, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1]]
											# fmt: on
											self.assertListEqual(x_token.input_ids						, __UpperCamelCase       )
											self.assertListEqual(x_token.token_type_ids						, __UpperCamelCase       )
											self.assertListEqual(x_token.attention_mask						, __UpperCamelCase       )
											self.assertListEqual(x_token_a.input_ids						, __UpperCamelCase       )
											self.assertListEqual(x_token_a.token_type_ids						, __UpperCamelCase       )
											self.assertListEqual(x_token_a.attention_mask						, __UpperCamelCase       )


				def __UpperCamelCase						(							self      :  Tuple       )		->     str:
											# Intentionally convert some words to accommodate character fluctuations unique to Japanese
											pass


				def __UpperCamelCase						(							self      :  Dict       )		->     int:
											# tokenizer has no padding token
											pass