

'''simple docstring'''






import pickle
import shutil
import tempfile
import unittest

from transformers import SPIECE_UNDERLINE, XGLMTokenizer, XGLMTokenizerFast
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      lowercase_      (lowerCamelCase__							,			unittest.TestCase ):




  """simple docstring"""




  SCREAMING_SNAKE_CASE       :    Optional[int]							     =     XGLMTokenizer
  SCREAMING_SNAKE_CASE       :    int							     =     XGLMTokenizerFast
  SCREAMING_SNAKE_CASE       :    List[str]							     =     True
  SCREAMING_SNAKE_CASE       :    Tuple							     =     True






  def    SCREAMING_SNAKE_CASE ( self  :	Tuple     ):
   super().setUp()

   # We have a SentencePiece fixture for testing
   __lowercase				    =					XGLMTokenizer(lowercase__   ,keep_accents=lowercase__     )
   tokenizer.save_pretrained(self.tmpdirname     )






  def    SCREAMING_SNAKE_CASE ( self  :	List[Any]     ):
   __lowercase				    =					'''<pad>'''
   __lowercase				    =					1

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






  def    SCREAMING_SNAKE_CASE ( self  :	int     ):
   __lowercase				    =					list(self.get_tokenizer().get_vocab().keys()     )

   self.assertEqual(vocab_keys[0]   ,'''<s>'''     )
   self.assertEqual(vocab_keys[1]   ,'''<pad>'''     )
   self.assertEqual(len(lowercase__     )   ,1_0_0_8     )






  def    SCREAMING_SNAKE_CASE ( self  :	Optional[Any]     ):
   self.assertEqual(self.get_tokenizer().vocab_size   ,1_0_0_8     )






  def    SCREAMING_SNAKE_CASE ( self  :	Optional[Any]     ):
   __lowercase				    =					XGLMTokenizer(lowercase__   ,keep_accents=lowercase__     )

   __lowercase				    =					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 [2_8_5, 4_6, 1_0, 1_7_0, 3_8_2]]   ,)

   __lowercase				    =					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''',
           '''é''',
           '''.''',
       ]   ,)
   __lowercase				    =					tokenizer.convert_tokens_to_ids(lowercase__     )
   self.assertListEqual(
       lowercase__   ,[
           value + tokenizer.fairseq_offset
           for value in [8, 2_1, 8_4, 5_5, 2_4, 1_9, 7, 2, 6_0_2, 3_4_7, 3_4_7, 3_4_7, 3, 1_2, 6_6, 4_6, 7_2, 8_0, 6, 2, 4]
       ]   ,)

   __lowercase				    =					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    SCREAMING_SNAKE_CASE ( self  :	int     ):
   return XGLMTokenizer.from_pretrained('''facebook/xglm-564M'''     )






  def    SCREAMING_SNAKE_CASE ( self  :	Optional[int]     ):
   with tempfile.NamedTemporaryFile() as f:
    shutil.copyfile(lowercase__   ,f.name     )
    __lowercase				    =					XGLMTokenizer(f.name   ,keep_accents=lowercase__     )
    __lowercase				    =					pickle.dumps(lowercase__     )
   pickle.loads(lowercase__     )






  def    SCREAMING_SNAKE_CASE ( self  :	List[str]     ):
   if not self.test_rust_tokenizer:
    return

   __lowercase				    =					self.get_tokenizer()
   __lowercase				    =					self.get_rust_tokenizer()

   __lowercase				    =					'''I was born in 92000, and this is falsé.'''

   __lowercase				    =					tokenizer.tokenize(lowercase__     )
   __lowercase				    =					rust_tokenizer.tokenize(lowercase__     )
   self.assertListEqual(lowercase__   ,lowercase__     )

   __lowercase				    =					tokenizer.encode(lowercase__   ,add_special_tokens=lowercase__     )
   __lowercase				    =					rust_tokenizer.encode(lowercase__   ,add_special_tokens=lowercase__     )
   self.assertListEqual(lowercase__   ,lowercase__     )

   __lowercase				    =					self.get_rust_tokenizer()
   __lowercase				    =					tokenizer.encode(lowercase__     )
   __lowercase				    =					rust_tokenizer.encode(lowercase__     )
   self.assertListEqual(lowercase__   ,lowercase__     )






  @slow
  def    SCREAMING_SNAKE_CASE ( self  :	Optional[int]     ):
   __lowercase				    =					'''Hello World!'''
   __lowercase				    =					[2, 3_1_2_2_7, 4_4_4_7, 3_5]

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






  @slow
  def    SCREAMING_SNAKE_CASE ( self  :	Any     ):
   __lowercase				    =					(
       '''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'''
   )
   # fmt: off
   __lowercase				    =					[2, 1_0_1_8, 6_7, 1_1, 1_9_8_8, 2_6_1_7, 5_6_3_1, 2_7_8, 1_1, 3_4_0_7, 4_8, 7_1_6_3_0, 2_8_0_8_5, 4, 3_2_3_4, 1_5_7, 1_3, 6, 5, 6, 4, 3_5_2_6, 7_6_8, 1_5, 6_5_9, 5_7, 2_9_8, 3_9_8_3, 8_6_4, 1_2_9, 2_1, 6, 5, 1_3_6_7_5, 3_7_7, 6_5_2, 7_5_8_0, 1_0_3_4_1, 1_5_5, 2_8_1_7, 4_2_2, 1_6_6_6, 7, 1_6_7_4, 5_3, 1_1_3, 2_0_2_2_7_7, 1_7_8_9_2, 3_3, 6_0, 8_7, 4, 3_2_3_4, 1_5_7, 6_1, 2_6_6_7, 5_2_3_7_6, 1_9, 8_8, 2_3, 7_3_5]
   # fmt: on

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






  @slow
  def    SCREAMING_SNAKE_CASE ( self  :	List[Any]     ):
   # fmt: off
   __lowercase				    =					{
       '''input_ids''': [[2, 1_0_8_8_2_5, 1_1_6_3, 1_5, 8_8_0_1_0, 4_7_3, 1_5_8_9_8, 1_5_7, 1_3_6_7_2, 1_8_5_7, 3_1_2, 8, 2_3_8_0_2_1, 1_1_6_3, 5_3, 1_3_6_7_2, 1_8_5_7, 3_1_2, 8, 5_3_2_8_3, 1_8_2_3_9_6, 8, 1_8_5_6_6, 1_6, 3_6_7_3_3, 4_1_0_1, 8, 2_3_0, 2_4_4_0_1_7, 1_2_2_5_5_3, 7, 1_5, 1_3_2_5_9_7, 4, 2_9_3, 1_2_5_1_1, 7_6_1_0, 4, 3_4_1_4, 1_3_2_5_9_7, 9, 4, 3_2_3_6_1, 3_6_2, 4, 7_3_4, 2_8_5_1_2, 3_2_5_6_9, 1_8, 4, 3_2_3_6_1, 2_6_0_9_6, 1_4_9_8_2, 7_3, 1_8_7_1_5, 2_1_4_3_3, 2_3_5_2_6_1, 1_5, 4_9_2, 1_2_4_2_7, 1_6, 5_3, 1_8_7_1_5, 2_1_4_3_3, 6_5_4_5_4, 1_5, 2_3_6_5_9, 5_6_3, 1_6, 2_7_8, 5_9_7, 2_8_4_3, 5_9_5, 7_9_3_1, 1_8_2_3_9_6, 6_4_1_8_6, 2_2, 8_8_6, 5_9_5, 1_3_2_9_8_1, 5_3, 2_5_5_4_0, 3_4_4_9, 4_3_9_8_2, 3_9_9_0_1, 5_9_5_1, 8_7_8, 3_3_0, 4, 2_7_6_9_4, 8_0_2_6_9, 3_1_2, 5_3, 6_5_1_7, 1_1_7_8_0, 6_1_1, 2_0_4_0_8, 5], [2, 6, 1_3_2_5_9_7, 6_7, 4_2_8_9_7, 3_3, 5_9_2, 8, 1_6_3_7_2_9, 2_5_5_4_0, 3_6_1, 1_3_6_9_9_7, 1_0_9_5_1_4, 1_7_3_2_3_0, 7, 5_0_1, 6_0, 1_0_2_9_1_3, 1_9_6, 5_6_3_1, 2_3_5, 6_3_2_4_3, 4_7_3, 6, 2_3_1_7_5_7, 7_4, 5_2_7_7, 7_9_0_5, 5_3, 3_0_9_5, 3_7_3_1_7, 2_2, 4_5_4, 1_8_3_8_7_4, 5], [2, 2_6_8, 3_1_2_9_8, 4_6_5_3_0, 6, 1_3_2_9_3_5, 4_3_8_3_1, 7, 5_9_7, 3_2, 2_4, 3_6_8_8, 9_8_6_5, 5]],
       '''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, 1, 1, 1]]
   }  # noqa: E501
   # fmt: on

   self.tokenizer_integration_test_util(
       expected_encoding=lowercase__   ,model_name='''facebook/xglm-564M'''   ,padding=lowercase__   ,)



import io
import os
import unicodedata
from typing import Any, Dict, List, Optional, Tuple

import sentencepiece as spm

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


__a         =   logging.get_logger(__name__)

__a         =   '▁'

__a         =   {'vocab_file': 'vocab.txt', 'sentencepiece_model_ckpt': 'sentencepiece.bpe.model'}

__a         =   {
    'sentencepiece_model_file': 'sentencepiece.bpe.model',
    'vocab_file': 'vocab.txt',
}

__a         =   {
    'vocab_file': {
        'ernie-m-base': 'https://huggingface.co/susnato/ernie-m-base_pytorch/blob/main/vocab.txt',
        'ernie-m-large': 'https://huggingface.co/susnato/ernie-m-base_pytorch/blob/main/vocab.txt',
    },
    'sentencepiece_model_file': {
        'ernie-m-base': 'https://huggingface.co/susnato/ernie-m-base_pytorch/blob/main/sentencepiece.bpe.model',
        'ernie-m-large': 'https://huggingface.co/susnato/ernie-m-base_pytorch/blob/main/sentencepiece.bpe.model',
    },
}

__a         =   {
    'ernie-m-base': 5_1_4,
    'ernie-m-large': 5_1_4,
}

__a         =   {
    'ernie-m-base': {'do_lower_case': False},
    'ernie-m-large': {'do_lower_case': False},
}
class 					lowercase__(							UpperCAmelCase				):



	"""simple docstring"""




	a     :List[str]       	=      ["input_ids"]

	a     :Dict       	=      VOCAB_FILES_NAMES
	a     :Union[str, Any]       	=      PRETRAINED_INIT_CONFIGURATION
	a     :Dict       	=      PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
	a     :List[str]       	=      PRETRAINED_VOCAB_FILES_MAP
	a     :Tuple       	=      RESOURCE_FILES_NAMES
	def __init__(			self    :     str			,				SCREAMING_SNAKE_CASE_    :     Optional[Any]			,				SCREAMING_SNAKE_CASE_    :     List[str]=None			,				SCREAMING_SNAKE_CASE_    :     List[Any]=False			,				SCREAMING_SNAKE_CASE_    :     Optional[Any]="utf8"			,				SCREAMING_SNAKE_CASE_    :     List[Any]="[UNK]"			,				SCREAMING_SNAKE_CASE_    :     Dict="[SEP]"			,				SCREAMING_SNAKE_CASE_    :     Union[str, Any]="[PAD]"			,				SCREAMING_SNAKE_CASE_    :     Optional[int]="[CLS]"			,				SCREAMING_SNAKE_CASE_    :     Optional[int]="[MASK]"			,				SCREAMING_SNAKE_CASE_    :     Optional[Dict[str, Any]] = None			,				**SCREAMING_SNAKE_CASE_    :     Optional[int]			,				)			->	None:
					# Mask token behave like a normal word, i.e. include the space before it and
					# is included in the raw text, there should be a match in a non-normalized sentence.

					lowercase_	    =   {} if sp_model_kwargs is None else sp_model_kwargs
					super().__init__(
					    do_lower_case=SCREAMING_SNAKE_CASE_			,				unk_token=SCREAMING_SNAKE_CASE_			,				sep_token=SCREAMING_SNAKE_CASE_			,				pad_token=SCREAMING_SNAKE_CASE_			,				cls_token=SCREAMING_SNAKE_CASE_			,				mask_token=SCREAMING_SNAKE_CASE_			,				vocab_file=SCREAMING_SNAKE_CASE_			,				encoding=SCREAMING_SNAKE_CASE_			,				sp_model_kwargs=self.sp_model_kwargs			,				**SCREAMING_SNAKE_CASE_			,				)
					lowercase_	    =   do_lower_case
					lowercase_	    =   sentencepiece_model_ckpt
					lowercase_	    =   spm.SentencePieceProcessor(**self.sp_model_kwargs			)
					self.sp_model.Load(SCREAMING_SNAKE_CASE_			)

					# to mimic paddlenlp.transformers.ernie_m.tokenizer.ErnieMTokenizer functioning
					if vocab_file is not None:
									lowercase_	    =   self.load_vocab(filepath=SCREAMING_SNAKE_CASE_			)
					else:
									lowercase_	    =   {self.sp_model.id_to_piece(SCREAMING_SNAKE_CASE_			): id for id in range(self.sp_model.get_piece_size()			)}
					lowercase_	    =   {v: k for k, v in self.vocab.items()}
	def 		_lowercase    (			self    :     Dict			,				SCREAMING_SNAKE_CASE_    :     str			)			->	List[Any]:
					if text is None:
									return None

					lowercase_	    =   self.tokenize(SCREAMING_SNAKE_CASE_			)
					lowercase_    ,      lowercase_	    =   '''''', []

					for i, ch in enumerate(SCREAMING_SNAKE_CASE_			):
									if ch in self.SP_CHAR_MAPPING:
													lowercase_	    =   self.SP_CHAR_MAPPING.get(SCREAMING_SNAKE_CASE_			)
									else:
													lowercase_	    =   unicodedata.normalize('''NFKC'''			,				SCREAMING_SNAKE_CASE_			)
									if self.is_whitespace(SCREAMING_SNAKE_CASE_			):
													continue
									normalized_text += ch
									char_mapping.extend([i] * len(SCREAMING_SNAKE_CASE_			)			)

					lowercase_    ,      lowercase_    ,      lowercase_	    =   normalized_text, [], 0

					if self.do_lower_case:
									lowercase_	    =   text.lower()

					for token in split_tokens:
									if token[:1] == "▁":
													lowercase_	    =   token[1:]
									lowercase_	    =   text[offset:].index(SCREAMING_SNAKE_CASE_			) + offset
									lowercase_	    =   start + len(SCREAMING_SNAKE_CASE_			)

									token_mapping.append((char_mapping[start], char_mapping[end - 1] + 1)			)
									lowercase_	    =   end
					return token_mapping
	@property
	def 		_lowercase    (			self    :     Union[str, Any]			)			->	Union[str, Any]:
					return len(self.vocab			)
	def 		_lowercase    (			self    :     Any			)			->	Optional[int]:
					return dict(self.vocab			,				**self.added_tokens_encoder			)
	def __getstate__(			self    :     Dict			)			->	int:
					lowercase_	    =   self.__dict__.copy()
					lowercase_	    =   None
					return state
	def __setstate__(			self    :     int			,				SCREAMING_SNAKE_CASE_    :     Any			)			->	List[Any]:
					lowercase_	    =   d

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

					lowercase_	    =   spm.SentencePieceProcessor(**self.sp_model_kwargs			)
					self.sp_model.Load(self.sentencepiece_model_ckpt			)
	def 		_lowercase    (			self    :     Optional[int]			,				SCREAMING_SNAKE_CASE_    :     Tuple			)			->	str:
					return "".join((self.SP_CHAR_MAPPING.get(SCREAMING_SNAKE_CASE_			,				SCREAMING_SNAKE_CASE_			) for c in text)			)
	def 		_lowercase    (			self    :     Dict			,				SCREAMING_SNAKE_CASE_    :     Optional[Any]			,				SCREAMING_SNAKE_CASE_    :     List[Any]=False			,				SCREAMING_SNAKE_CASE_    :     Optional[int]=6_4			,				SCREAMING_SNAKE_CASE_    :     List[str]=0.1			)			->	Any:

					if self.sp_model_kwargs.get('''enable_sampling'''			) is True:
									lowercase_	    =   True
					if self.sp_model_kwargs.get('''alpha'''			) is not None:
									lowercase_	    =   self.sp_model_kwargs.get('''alpha'''			)
					if self.sp_model_kwargs.get('''nbest_size'''			) is not None:
									lowercase_	    =   self.sp_model_kwargs.get('''nbest_size'''			)

					if not enable_sampling:
									lowercase_	    =   self.sp_model.EncodeAsPieces(SCREAMING_SNAKE_CASE_			)
					else:
									lowercase_	    =   self.sp_model.SampleEncodeAsPieces(SCREAMING_SNAKE_CASE_			,				SCREAMING_SNAKE_CASE_			,				SCREAMING_SNAKE_CASE_			)
					lowercase_	    =   []
					for pi, piece in enumerate(SCREAMING_SNAKE_CASE_			):
									if piece == SPIECE_UNDERLINE:
													if not pieces[pi + 1].startswith(SCREAMING_SNAKE_CASE_			) and pi != 0:
																	new_pieces.append(SCREAMING_SNAKE_CASE_			)
																	continue
													else:
																	continue
									lowercase_	    =   0
									for i, chunk in enumerate(SCREAMING_SNAKE_CASE_			):
													if chunk == SPIECE_UNDERLINE:
																	continue
													if self.is_ch_char(SCREAMING_SNAKE_CASE_			) or self.is_punct(SCREAMING_SNAKE_CASE_			):
																	if i > lst_i and piece[lst_i:i] != SPIECE_UNDERLINE:
																					new_pieces.append(piece[lst_i:i]			)
																	new_pieces.append(SCREAMING_SNAKE_CASE_			)
																	lowercase_	    =   i + 1
													elif chunk.isdigit() and i > 0 and not piece[i - 1].isdigit():
																	if i > lst_i and piece[lst_i:i] != SPIECE_UNDERLINE:
																					new_pieces.append(piece[lst_i:i]			)
																	lowercase_	    =   i
													elif not chunk.isdigit() and i > 0 and piece[i - 1].isdigit():
																	if i > lst_i and piece[lst_i:i] != SPIECE_UNDERLINE:
																					new_pieces.append(piece[lst_i:i]			)
																	lowercase_	    =   i
									if len(SCREAMING_SNAKE_CASE_			) > lst_i:
													new_pieces.append(piece[lst_i:]			)
					return new_pieces
	def 		_lowercase    (			self    :     Tuple			,				SCREAMING_SNAKE_CASE_    :     Any			)			->	Optional[Any]:
					lowercase_	    =   ''''''.join(SCREAMING_SNAKE_CASE_			).replace(SCREAMING_SNAKE_CASE_			,				''' '''			).strip()
					return out_string
	def 		_lowercase    (			self    :     Optional[Any]			,				SCREAMING_SNAKE_CASE_    :     Tuple			)			->	Any:
					lowercase_	    =   self.convert_ids_to_tokens(SCREAMING_SNAKE_CASE_			)
					lowercase_	    =   ''''''.join(SCREAMING_SNAKE_CASE_			).replace(SCREAMING_SNAKE_CASE_			,				''' '''			).strip()
					return out_string
	def 		_lowercase    (			self    :     str			,				SCREAMING_SNAKE_CASE_    :     List[str]			)			->	List[str]:
					return self.vocab.get(SCREAMING_SNAKE_CASE_			,				self.vocab.get(self.unk_token			)			)
	def 		_lowercase    (			self    :     str			,				SCREAMING_SNAKE_CASE_    :     List[Any]			)			->	List[Any]:
					return self.reverse_vocab.get(SCREAMING_SNAKE_CASE_			,				self.unk_token			)
	def 		_lowercase    (			self    :     List[Any]			,				SCREAMING_SNAKE_CASE_    :     Any			,				SCREAMING_SNAKE_CASE_    :     str=None			)			->	List[str]:
					if token_ids_a is None:
									return [self.cls_token_id] + token_ids_a + [self.sep_token_id]
					lowercase_	    =   [self.cls_token_id]
					lowercase_	    =   [self.sep_token_id]
					return _cls + token_ids_a + _sep + _sep + token_ids_a + _sep
	def 		_lowercase    (			self    :     Dict			,				SCREAMING_SNAKE_CASE_    :     Optional[Any]			,				SCREAMING_SNAKE_CASE_    :     List[str]=None			)			->	int:
					if offset_mapping_a is None:
									return [(0, 0)] + offset_mapping_a + [(0, 0)]

					return [(0, 0)] + offset_mapping_a + [(0, 0), (0, 0)] + offset_mapping_a + [(0, 0)]
	def 		_lowercase    (			self    :     Tuple			,				SCREAMING_SNAKE_CASE_    :     Any			,				SCREAMING_SNAKE_CASE_    :     Optional[int]=None			,				SCREAMING_SNAKE_CASE_    :     Optional[int]=False			)			->	Any:

					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 not None:
									return [1] + ([0] * len(SCREAMING_SNAKE_CASE_			)) + [1, 1] + ([0] * len(SCREAMING_SNAKE_CASE_			)) + [1]
					return [1] + ([0] * len(SCREAMING_SNAKE_CASE_			)) + [1]
	def 		_lowercase    (			self    :     Dict			,				SCREAMING_SNAKE_CASE_    :     List[int]			,				SCREAMING_SNAKE_CASE_    :     Optional[List[int]] = None			)			->	List[int]:
					# called when `add_special_tokens` is True, so align with `build_inputs_with_special_tokens` method
					if token_ids_a is None:
									# [CLS] X [SEP]
									return (len(SCREAMING_SNAKE_CASE_			) + 2) * [0]

					# [CLS] A [SEP] [SEP] B [SEP]
					return [0] * (len(SCREAMING_SNAKE_CASE_			) + 1) + [1] * (len(SCREAMING_SNAKE_CASE_			) + 3)
	def 		_lowercase    (			self    :     List[Any]			,				SCREAMING_SNAKE_CASE_    :     List[str]			)			->	Optional[int]:
					if "\u4e00" <= char <= "\u9fff":
									return True
					return False
	def 		_lowercase    (			self    :     List[Any]			,				SCREAMING_SNAKE_CASE_    :     Union[str, Any]			)			->	Tuple:
					if ("a" <= char <= "z") or ("A" <= char <= "Z"):
									return True
					return False
	def 		_lowercase    (			self    :     List[str]			,				SCREAMING_SNAKE_CASE_    :     int			)			->	List[Any]:
					if char in ",;:.?!~，；：。？！《》【】":
									return True
					return False
	def 		_lowercase    (			self    :     Optional[int]			,				SCREAMING_SNAKE_CASE_    :     Optional[Any]			)			->	Union[str, Any]:
					if char == " " or char == "\t" or char == "\n" or char == "\r":
									return True
					if len(SCREAMING_SNAKE_CASE_			) == 1:
									lowercase_	    =   unicodedata.category(SCREAMING_SNAKE_CASE_			)
									if cat == "Zs":
													return True
					return False
	def 		_lowercase    (			self    :     Any			,				SCREAMING_SNAKE_CASE_    :     Any			)			->	Tuple:
					lowercase_	    =   {}
					with io.open(SCREAMING_SNAKE_CASE_			,				'''r'''			,				encoding='''utf-8'''			) as f:
									for index, line in enumerate(SCREAMING_SNAKE_CASE_			):
													lowercase_	    =   line.rstrip('''\n'''			)
													lowercase_	    =   int(SCREAMING_SNAKE_CASE_			)

					return token_to_idx




	def 		_lowercase    (			self    :     Tuple			,				SCREAMING_SNAKE_CASE_    :     str			,				SCREAMING_SNAKE_CASE_    :     Optional[str] = None			)			->	Tuple[str]:
					lowercase_	    =   0
					if os.path.isdir(SCREAMING_SNAKE_CASE_			):
									lowercase_	    =   os.path.join(
									    SCREAMING_SNAKE_CASE_			,				(filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''vocab_file''']			)
					else:
									lowercase_	    =   (filename_prefix + '''-''' if filename_prefix else '''''') + save_directory
					with open(SCREAMING_SNAKE_CASE_			,				'''w'''			,				encoding='''utf-8'''			) as writer:
									for token, token_index in sorted(self.vocab.items()			,				key=lambda SCREAMING_SNAKE_CASE_			: kv[1]			):
													if index != token_index:
																	logger.warning(
																	    f'''Saving vocabulary to {vocab_file}: vocabulary indices are not consecutive.'''
																	    ''' Please check that the vocabulary is not corrupted!'''			)
																	lowercase_	    =   token_index
													writer.write(token + '''\n'''			)
													index += 1

					lowercase_	    =   os.path.join(SCREAMING_SNAKE_CASE_			,				'''sentencepiece.bpe.model'''			)
					with open(SCREAMING_SNAKE_CASE_			,				'''wb'''			) as fi:
									lowercase_	    =   self.sp_model.serialized_model_proto()
									fi.write(SCREAMING_SNAKE_CASE_			)

					return (vocab_file,)




