





"""simple docstring"""
from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


lowerCamelCase_       =		{
    "configuration_x_clip": [
        "XCLIP_PRETRAINED_CONFIG_ARCHIVE_MAP",
        "XCLIPConfig",
        "XCLIPTextConfig",
        "XCLIPVisionConfig",
    ],
    "processing_x_clip": ["XCLIPProcessor"],
}

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  lowerCamelCase_       =		[
      "XCLIP_PRETRAINED_MODEL_ARCHIVE_LIST",
      "XCLIPModel",
      "XCLIPPreTrainedModel",
      "XCLIPTextModel",
      "XCLIPVisionModel",
  ]

if TYPE_CHECKING:
  from .configuration_x_clip import (
      XCLIP_PRETRAINED_CONFIG_ARCHIVE_MAP,
      XCLIPConfig,
      XCLIPTextConfig,
      XCLIPVisionConfig,
  )
  from .processing_x_clip import XCLIPProcessor

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_x_clip import (
        XCLIP_PRETRAINED_MODEL_ARCHIVE_LIST,
        XCLIPModel,
        XCLIPPreTrainedModel,
        XCLIPTextModel,
        XCLIPVisionModel,
    )

else:
  import sys

  lowerCamelCase_       =		_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)






"""simple docstring"""
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


lowerCamelCase_       =		logging.get_logger(__name__)

lowerCamelCase_       =		{"vocab_file": "spiece.model"}

lowerCamelCase_       =		{
    "vocab_file": {
        "bert_for_seq_generation": (
            "https://huggingface.co/google/bert_for_seq_generation_L-24_bbc_encoder/resolve/main/spiece.model"
        ),
    }
}

lowerCamelCase_       =		{"bert_for_seq_generation": 5_1_2}






class  _SCREAMING_SNAKE_CASE(       A  ):
       SCREAMING_SNAKE_CASE_       :				str     						=  VOCAB_FILES_NAMES
       SCREAMING_SNAKE_CASE_       :				Optional[Any]     						=  PRETRAINED_VOCAB_FILES_MAP
       SCREAMING_SNAKE_CASE_       :				Optional[int]     						=  PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
       SCREAMING_SNAKE_CASE_       :				List[int]     						=  []
       SCREAMING_SNAKE_CASE_       :				List[Any]     						=  ['''input_ids''', '''attention_mask''']




       def __init__(						self		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__="<s>"		,SCREAMING_SNAKE_CASE__="</s>"		,SCREAMING_SNAKE_CASE__="<unk>"		,SCREAMING_SNAKE_CASE__="<pad>"		,SCREAMING_SNAKE_CASE__="<::::>"		,SCREAMING_SNAKE_CASE__ = None		,**SCREAMING_SNAKE_CASE__		,)      ->				None:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE       :Optional[Any]		    =  {} if sp_model_kwargs is None else sp_model_kwargs

             # Add extra_ids to the special token list
             super().__init__(
                 bos_token=SCREAMING_SNAKE_CASE__		,eos_token=SCREAMING_SNAKE_CASE__		,unk_token=SCREAMING_SNAKE_CASE__		,pad_token=SCREAMING_SNAKE_CASE__		,sep_token=SCREAMING_SNAKE_CASE__		,sp_model_kwargs=self.sp_model_kwargs		,**SCREAMING_SNAKE_CASE__		,)

             __SCREAMING_SNAKE_CASE       :Dict		    =  vocab_file

             __SCREAMING_SNAKE_CASE       :Optional[Any]		    =  spm.SentencePieceProcessor(**self.sp_model_kwargs							)
             self.sp_model.Load(SCREAMING_SNAKE_CASE__							)




       @property
       def    _UpperCamelCase					(						self							)      ->				List[str]:





             """simple docstring"""






             return self.sp_model.get_piece_size()




       def    _UpperCamelCase					(						self							)      ->				int:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE       :List[Any]		    =  {self.convert_ids_to_tokens(SCREAMING_SNAKE_CASE__							): i for i in range(self.vocab_size							)}
             vocab.update(self.added_tokens_encoder							)
             return vocab




       def __getstate__(						self							)      ->				Dict:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE       :int		    =  self.__dict__.copy()
             __SCREAMING_SNAKE_CASE       :Dict		    =  None
             return state




       def __setstate__(						self		,SCREAMING_SNAKE_CASE__							)      ->				Optional[Any]:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE       :List[str]		    =  d

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

             __SCREAMING_SNAKE_CASE       :str		    =  spm.SentencePieceProcessor(**self.sp_model_kwargs							)
             self.sp_model.Load(self.vocab_file							)




       def    _UpperCamelCase					(						self		,SCREAMING_SNAKE_CASE__							)      ->				List[str]:





             """simple docstring"""






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




       def    _UpperCamelCase					(						self		,SCREAMING_SNAKE_CASE__							)      ->				int:





             """simple docstring"""






             return self.sp_model.piece_to_id(SCREAMING_SNAKE_CASE__							)




       def    _UpperCamelCase					(						self		,SCREAMING_SNAKE_CASE__							)      ->				str:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE       :Optional[int]		    =  self.sp_model.IdToPiece(SCREAMING_SNAKE_CASE__							)
             return token




       def    _UpperCamelCase					(						self		,SCREAMING_SNAKE_CASE__							)      ->				List[Any]:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE       :int		    =  []
             __SCREAMING_SNAKE_CASE       :List[str]		    =  ''''''
             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(SCREAMING_SNAKE_CASE__							) + token
                         __SCREAMING_SNAKE_CASE       :Dict		    =  []
                   else:
                         current_sub_tokens.append(SCREAMING_SNAKE_CASE__							)
             out_string += self.sp_model.decode(SCREAMING_SNAKE_CASE__							)
             return out_string.strip()




       def    _UpperCamelCase					(						self		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__ = None							)      ->				Tuple[str]:





             """simple docstring"""






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

             if os.path.abspath(self.vocab_file							) != os.path.abspath(SCREAMING_SNAKE_CASE__							) and os.path.isfile(self.vocab_file							):
                   copyfile(self.vocab_file		,SCREAMING_SNAKE_CASE__							)
             elif not os.path.isfile(self.vocab_file							):
                   with open(SCREAMING_SNAKE_CASE__		,'''wb'''							) as fi:
                         __SCREAMING_SNAKE_CASE       :Tuple		    =  self.sp_model.serialized_model_proto()
                         fi.write(SCREAMING_SNAKE_CASE__							)

             return (out_vocab_file,)