

"""simple docstring"""




from google.protobuf import descriptor as _descriptor
from google.protobuf import descriptor_pool as _descriptor_pool
from google.protobuf import symbol_database as _symbol_database
from google.protobuf.internal import builder as _builder


# @@protoc_insertion_point(imports)

A_							:			str											= _symbol_database.Default()


A_							:			str											= _descriptor_pool.Default().AddSerializedFile(
    b"\n\x19sentencepiece_model.proto\x12\rsentencepiece\"\x80\x0c\n\x0bTrainerSpec\x12\r\n\x05input\x18\x01 \x03(\t\x12\x14\n\x0cinput_format\x18\x07 \x01(\t\x12\x14\n\x0cmodel_prefix\x18\x02 \x01(\t\x12\x41\n\nmodel_type\x18\x03 \x01(\x0e\x32$.sentencepiece.TrainerSpec.ModelType:\x07UNIGRAM\x12\x18\n\nvocab_size\x18\x04 \x01(\x05:\x04\x38\x30\x30\x30\x12\x17\n\x0f\x61\x63\x63\x65pt_language\x18\x05 \x03(\t\x12 \n\x15self_test_sample_size\x18\x06 \x01(\x05:\x01\x30\x12*\n\x1b\x65nable_differential_privacy\x18\x32 \x01(\x08:\x05\x66\x61lse\x12+\n differential_privacy_noise_level\x18\x33 \x01(\x02:\x01\x30\x12\x32\n\'differential_privacy_clipping_threshold\x18\x34 \x01(\x04:\x01\x30\x12\"\n\x12\x63haracter_coverage\x18\n \x01(\x02:\x06\x30.9995\x12\x1e\n\x13input_sentence_size\x18\x0b \x01(\x04:\x01\x30\x12$\n\x16shuffle_input_sentence\x18\x13 \x01(\x08:\x04true\x12 \n\x14mining_sentence_size\x18\x0c \x01(\x05\x42\x02\x18\x01\x12\"\n\x16training_sentence_size\x18\r \x01(\x05\x42\x02\x18\x01\x12(\n\x17seed_sentencepiece_size\x18\x0e \x01(\x05:\x07\x31\x30\x30\x30\x30\x30\x30\x12\x1e\n\x10shrinking_factor\x18\x0f \x01(\x02:\x04\x30.75\x12!\n\x13max_sentence_length\x18\x12 \x01(\x05:\x04\x34\x31\x39\x32\x12\x17\n\x0bnum_threads\x18\x10 \x01(\x05:\x02\x31\x36\x12\x1d\n\x12num_sub_iterations\x18\x11 \x01(\x05:\x01\x32\x12$\n\x18max_sentencepiece_length\x18\x14 \x01(\x05:\x02\x31\x36\x12%\n\x17split_by_unicode_script\x18\x15 \x01(\x08:\x04true\x12\x1d\n\x0fsplit_by_number\x18\x17 \x01(\x08:\x04true\x12!\n\x13split_by_whitespace\x18\x16 \x01(\x08:\x04true\x12)\n\x1atreat_whitespace_as_suffix\x18\x18 \x01(\x08:\x05\x66\x61lse\x12+\n\x1c\x61llow_whitespace_only_pieces\x18\x1a \x01(\x08:\x05\x66\x61lse\x12\x1b\n\x0csplit_digits\x18\x19 \x01(\x08:\x05\x66\x61lse\x12#\n\x19pretokenization_delimiter\x18\x35 \x01(\t:\x00\x12\x17\n\x0f\x63ontrol_symbols\x18\x1e \x03(\t\x12\x1c\n\x14user_defined_symbols\x18\x1f \x03(\t\x12\x16\n\x0erequired_chars\x18$ \x01(\t\x12\x1c\n\rbyte_fallback\x18# \x01(\x08:\x05\x66\x61lse\x12+\n\x1dvocabulary_output_piece_score\x18  \x01(\x08:\x04true\x12\x1e\n\x10hard_vocab_limit\x18! \x01(\x08:\x04true\x12\x1c\n\ruse_all_vocab\x18\" \x01(\x08:\x05\x66\x61lse\x12\x11\n\x06unk_id\x18( \x01(\x05:\x01\x30\x12\x11\n\x06\x62os_id\x18) \x01(\x05:\x01\x31\x12\x11\n\x06\x65os_id\x18* \x01(\x05:\x01\x32\x12\x12\n\x06pad_id\x18+ \x01(\x05:\x02-1\x12\x18\n\tunk_piece\x18- \x01(\t:\x05<unk>\x12\x16\n\tbos_piece\x18. \x01(\t:\x03<s>\x12\x17\n\teos_piece\x18/ \x01(\t:\x04</s>\x12\x18\n\tpad_piece\x18\x30 \x01(\t:\x05<pad>\x12\x1a\n\x0bunk_surface\x18, \x01(\t:\x05 \xe2\x81\x87 \x12+\n\x1ctrain_extremely_large_corpus\x18\x31 \x01(\x08:\x05\x66\x61lse\"5\n\tModelType\x12\x0b\n\x07UNIGRAM\x10\x01\x12\x07\n\x03\x42PE\x10\x02\x12\x08\n\x04WORD\x10\x03\x12\x08\n\x04\x43HAR\x10\x04*\t\x08\xc8\x01\x10\x80\x80\x80\x80\x02\"\xd1\x01\n\x0eNormalizerSpec\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x1c\n\x14precompiled_charsmap\x18\x02 \x01(\x0c\x12\x1e\n\x10\x61\x64\x64_dummy_prefix\x18\x03 \x01(\x08:\x04true\x12&\n\x18remove_extra_whitespaces\x18\x04 \x01(\x08:\x04true\x12 \n\x12\x65scape_whitespaces\x18\x05 \x01(\x08:\x04true\x12\x1e\n\x16normalization_rule_tsv\x18\x06 \x01(\t*\t\x08\xc8\x01\x10\x80\x80\x80\x80\x02\"y\n\x0cSelfTestData\x12\x33\n\x07samples\x18\x01 \x03(\x0b\x32\".sentencepiece.SelfTestData.Sample\x1a)\n\x06Sample\x12\r\n\x05input\x18\x01 \x01(\t\x12\x10\n\x08\x65xpected\x18\x02 \x01(\t*\t\x08\xc8\x01\x10\x80\x80\x80\x80\x02\"\xfe\x03\n\nModelProto\x12\x37\n\x06pieces\x18\x01 \x03(\x0b\x32\'.sentencepiece.ModelProto.SentencePiece\x12\x30\n\x0ctrainer_spec\x18\x02 \x01(\x0b\x32\x1a.sentencepiece.TrainerSpec\x12\x36\n\x0fnormalizer_spec\x18\x03 \x01(\x0b\x32\x1d.sentencepiece.NormalizerSpec\x12\x33\n\x0eself_test_data\x18\x04 \x01(\x0b\x32\x1b.sentencepiece.SelfTestData\x12\x38\n\x11\x64\x65normalizer_spec\x18\x05 \x01(\x0b\x32\x1d.sentencepiece.NormalizerSpec\x1a\xd2\x01\n\rSentencePiece\x12\r\n\x05piece\x18\x01 \x01(\t\x12\r\n\x05score\x18\x02 \x01(\x02\x12\x42\n\x04type\x18\x03 \x01(\x0e\x32,.sentencepiece.ModelProto.SentencePiece.Type:\x06NORMAL\"T\n\x04Type\x12\n\n\x06NORMAL\x10\x01\x12\x0b\n\x07UNKNOWN\x10\x02\x12\x0b\n\x07\x43ONTROL\x10\x03\x12\x10\n\x0cUSER_DEFINED\x10\x04\x12\x08\n\x04\x42YTE\x10\x06\x12\n\n\x06UNUSED\x10\x05*\t\x08\xc8\x01\x10\x80\x80\x80\x80\x02*\t\x08\xc8\x01\x10\x80\x80\x80\x80\x02\x42\x02H\x03"
)

A_							:			Optional[int]											= globals()
_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, "sentencepiece_model_pb2", _globals)
if _descriptor._USE_C_DESCRIPTORS is False:
						A_							:			Dict											= None
						A_							:			int											= b"H\003"
						# (generated by protobuf compiler, but `_TRAINERSPEC` is not defined)
						# _TRAINERSPEC.fields_by_name["mining_sentence_size"]._options = None
						# _TRAINERSPEC.fields_by_name["mining_sentence_size"]._serialized_options = b"\030\001"
						# _TRAINERSPEC.fields_by_name["training_sentence_size"]._options = None
						# _TRAINERSPEC.fields_by_name["training_sentence_size"]._serialized_options = b"\030\001"
						A_							:			Optional[int]											= 45
						A_							:			Union[str, Any]											= 1_581
						A_							:			Any											= 1_517
						A_							:			Dict											= 1_570
						A_							:			int											= 1_584
						A_							:			int											= 1_793
						A_							:			Tuple											= 1_795
						A_							:			Optional[int]											= 1_916
						A_							:			Union[str, Any]											= 1_864
						A_							:			str											= 1_905
						A_							:			Dict											= 1_919
						A_							:			str											= 2_429
						A_							:			List[Any]											= 2_208
						A_							:			List[str]											= 2_418
						A_							:			str											= 2_323
						A_							:			Dict											= 2_407
# @@protoc_insertion_point(module_scope)





"""simple docstring"""




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

import sentencepiece as spm

from ...tokenization_utils import AddedToken, PreTrainedTokenizer
from ...utils import logging


A_							:			Optional[int]											= logging.get_logger(__name__)

A_							:			Union[str, Any]											= {"vocab_file": "sentencepiece.bpe.model"}

A_							:			str											= {
    "vocab_file": {
        "camembert-base": "https://huggingface.co/camembert-base/resolve/main/sentencepiece.bpe.model",
    }
}

A_							:			Tuple											= {
    "camembert-base": 512,
}

A_							:			int											= "▁"





class    lowerCamelCase						(A__			):
			lowerCamelCase__   :		int							=							VOCAB_FILES_NAMES
			lowerCamelCase__   :		List[Any]							=							PRETRAINED_VOCAB_FILES_MAP
			lowerCamelCase__   :		List[str]							=							PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
			lowerCamelCase__   :		Optional[int]							=							['input_ids', 'attention_mask']

			def __init__(					self				:						Tuple    ,				__UpperCAmelCase				:						Optional[Any]    ,				__UpperCAmelCase				:						int="<s>"    ,				__UpperCAmelCase				:						Union[str, Any]="</s>"    ,				__UpperCAmelCase				:						List[str]="</s>"    ,				__UpperCAmelCase				:						List[Any]="<s>"    ,				__UpperCAmelCase				:						int="<unk>"    ,				__UpperCAmelCase				:						Dict="<pad>"    ,				__UpperCAmelCase				:						int="<mask>"    ,				__UpperCAmelCase				:						List[Any]=["<s>NOTUSED", "</s>NOTUSED"]    ,				__UpperCAmelCase				:						Optional[Dict[str, Any]] = None    ,				**__UpperCAmelCase				:						Optional[Any]    ,				)   ->    None:
						# Mask token behave like a normal word, i.e. include the space before it
						SCREAMING_SNAKE_CASE__								=      AddedToken(__UpperCAmelCase    ,				lstrip=__UpperCAmelCase    ,				rstrip=__UpperCAmelCase       ) if isinstance(__UpperCAmelCase    ,				__UpperCAmelCase       ) else mask_token

						SCREAMING_SNAKE_CASE__								=      {} if sp_model_kwargs is None else sp_model_kwargs

						super().__init__(
						    bos_token=__UpperCAmelCase    ,				eos_token=__UpperCAmelCase    ,				unk_token=__UpperCAmelCase    ,				sep_token=__UpperCAmelCase    ,				cls_token=__UpperCAmelCase    ,				pad_token=__UpperCAmelCase    ,				mask_token=__UpperCAmelCase    ,				additional_special_tokens=__UpperCAmelCase    ,				sp_model_kwargs=self.sp_model_kwargs    ,				**__UpperCAmelCase    ,				)
						SCREAMING_SNAKE_CASE__								=      spm.SentencePieceProcessor(**self.sp_model_kwargs       )
						self.sp_model.Load(str(__UpperCAmelCase       )       )
						SCREAMING_SNAKE_CASE__								=      vocab_file
						# HACK: These tokens were added by fairseq but don't seem to be actually used when duplicated in the actual
						# sentencepiece vocabulary (this is the case for <s> and </s>
						SCREAMING_SNAKE_CASE__								=      {"""<s>NOTUSED""": 0, """<pad>""": 1, """</s>NOTUSED""": 2, """<unk>""": 3}
						SCREAMING_SNAKE_CASE__								=      len(self.fairseq_tokens_to_ids       )
						SCREAMING_SNAKE_CASE__								=      len(self.sp_model       ) + len(self.fairseq_tokens_to_ids       )
						SCREAMING_SNAKE_CASE__								=      {v: k for k, v in self.fairseq_tokens_to_ids.items()}

			def 					SCREAMING_SNAKE_CASE				(					self				:						Optional[int]    ,				__UpperCAmelCase				:						List[int]    ,				__UpperCAmelCase				:						Optional[List[int]] = None       )   ->    List[int]:

						if token_ids_a is None:
									return [self.cls_token_id] + token_ids_a + [self.sep_token_id]
						SCREAMING_SNAKE_CASE__								=      [self.cls_token_id]
						SCREAMING_SNAKE_CASE__								=      [self.sep_token_id]
						return cls + token_ids_a + sep + sep + token_ids_a + sep

			def 					SCREAMING_SNAKE_CASE				(					self				:						Optional[int]    ,				__UpperCAmelCase				:						List[int]    ,				__UpperCAmelCase				:						Optional[List[int]] = None    ,				__UpperCAmelCase				:						bool = False       )   ->    List[int]:
						if already_has_special_tokens:
									return super().get_special_tokens_mask(
									    token_ids_a=__UpperCAmelCase    ,				token_ids_a=__UpperCAmelCase    ,				already_has_special_tokens=__UpperCAmelCase       )

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

			def 					SCREAMING_SNAKE_CASE				(					self				:						Tuple    ,				__UpperCAmelCase				:						List[int]    ,				__UpperCAmelCase				:						Optional[List[int]] = None       )   ->    List[int]:
						SCREAMING_SNAKE_CASE__								=      [self.sep_token_id]
						SCREAMING_SNAKE_CASE__								=      [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 + sep + token_ids_a + sep       ) * [0]

			@property
			def 					SCREAMING_SNAKE_CASE				(					self				:						Any       )   ->    Any:
						return len(self.fairseq_tokens_to_ids       ) + len(self.sp_model       )

			def 					SCREAMING_SNAKE_CASE				(					self				:						int       )   ->    Optional[Any]:
						SCREAMING_SNAKE_CASE__								=      {self.convert_ids_to_tokens(__UpperCAmelCase       ): i for i in range(self.vocab_size       )}
						vocab.update(self.added_tokens_encoder       )
						return vocab

			def 					SCREAMING_SNAKE_CASE				(					self				:						Optional[int]    ,				__UpperCAmelCase				:						str       )   ->    List[str]:
						return self.sp_model.encode(__UpperCAmelCase    ,				out_type=__UpperCAmelCase       )

			def 					SCREAMING_SNAKE_CASE				(					self				:						Tuple    ,				__UpperCAmelCase				:						Tuple       )   ->    Optional[Any]:
						if token in self.fairseq_tokens_to_ids:
									return self.fairseq_tokens_to_ids[token]
						elif self.sp_model.PieceToId(__UpperCAmelCase       ) == 0:
									# Convert sentence piece unk token to fairseq unk token index
									return self.unk_token_id
						return self.fairseq_offset + self.sp_model.PieceToId(__UpperCAmelCase       )

			def 					SCREAMING_SNAKE_CASE				(					self				:						Optional[Any]    ,				__UpperCAmelCase				:						int       )   ->    Dict:
						if index in self.fairseq_ids_to_tokens:
									return self.fairseq_ids_to_tokens[index]
						return self.sp_model.IdToPiece(index - self.fairseq_offset       )

			def 					SCREAMING_SNAKE_CASE				(					self				:						Optional[int]    ,				__UpperCAmelCase				:						List[str]       )   ->    Union[str, Any]:
						SCREAMING_SNAKE_CASE__								=      []
						SCREAMING_SNAKE_CASE__								=      """"""
						SCREAMING_SNAKE_CASE__								=      False
						for token in tokens:
									# make sure that special tokens are not decoded using sentencepiece model
									if token in self.all_special_tokens:
												if not prev_is_special:
															out_string += " "
												out_string += self.sp_model.decode(__UpperCAmelCase       ) + token
												SCREAMING_SNAKE_CASE__								=      True
												SCREAMING_SNAKE_CASE__								=      []
									else:
												current_sub_tokens.append(__UpperCAmelCase       )
												SCREAMING_SNAKE_CASE__								=      False
						out_string += self.sp_model.decode(__UpperCAmelCase       )
						return out_string.strip()

			def __getstate__(					self				:						Optional[Any]       )   ->    Any:
						SCREAMING_SNAKE_CASE__								=      self.__dict__.copy()
						SCREAMING_SNAKE_CASE__								=      None
						return state

			def __setstate__(					self				:						int    ,				__UpperCAmelCase				:						Optional[int]       )   ->    str:
						SCREAMING_SNAKE_CASE__								=      d

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

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





			def 					SCREAMING_SNAKE_CASE				(					self				:						Optional[Any]    ,				__UpperCAmelCase				:						str    ,				__UpperCAmelCase				:						Optional[str] = None       )   ->    Tuple[str]:
						if not os.path.isdir(__UpperCAmelCase       ):
									logger.error(F"""Vocabulary path ({save_directory}) should be a directory"""       )
									return
						SCREAMING_SNAKE_CASE__								=      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:
												SCREAMING_SNAKE_CASE__								=      self.sp_model.serialized_model_proto()
												fi.write(__UpperCAmelCase       )

						return (out_vocab_file,)


