





'''simple docstring'''


import tempfile
import unittest

import numpy as np

from diffusers import (
    DDIMScheduler,
    DPMSolverMultistepScheduler,
    EulerAncestralDiscreteScheduler,
    EulerDiscreteScheduler,
    LMSDiscreteScheduler,
    OnnxStableDiffusionPipeline,
    PNDMScheduler,
)
from diffusers.utils.testing_utils import is_onnx_available, nightly, require_onnxruntime, require_torch_gpu

from ..test_pipelines_onnx_common import OnnxPipelineTesterMixin


if is_onnx_available():
       import onnxruntime as ort

class    lowerCAmelCase_		(		__magic_name__						,unittest.TestCase		):
 __lowerCamelCase						:							int       					=					"hf-internal-testing/tiny-random-OnnxStableDiffusionPipeline"




 def 							_snake_case   (	self			,     _lowerCAmelCase=0		)    ->							Union[str, Any]:
     _lowerCAmelCase				=      np.random.RandomState(_lowerCAmelCase		)
     _lowerCAmelCase				=      {
         "prompt": "A painting of a squirrel eating a burger",
         "generator": generator,
         "num_inference_steps": 2,
         "guidance_scale": 7.5,
         "output_type": "numpy",
     }
     return inputs




 def 							_snake_case   (	self		)    ->							Tuple:
     _lowerCAmelCase				=      OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint			,     provider="CPUExecutionProvider"		)
     pipe.set_progress_bar_config(disable=_lowerCAmelCase		)

     _lowerCAmelCase				=      self.get_dummy_inputs()
     _lowerCAmelCase				=      pipe(**_lowerCAmelCase		).images
     _lowerCAmelCase				=      image[0, -3:, -3:, -1]

     assert image.shape == (1, 128, 128, 3)
     _lowerCAmelCase				=      np.array([0.65072, 0.58492, 0.48219, 0.55521, 0.53180, 0.55939, 0.50697, 0.39800, 0.46455]		)

     assert np.abs(image_slice.flatten() - expected_slice		).max() < 1E-2




 def 							_snake_case   (	self		)    ->							Dict:
     _lowerCAmelCase				=      OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint			,     provider="CPUExecutionProvider"		)
     _lowerCAmelCase				=      PNDMScheduler.from_config(pipe.scheduler.config			,     skip_prk_steps=_lowerCAmelCase		)
     pipe.set_progress_bar_config(disable=_lowerCAmelCase		)

     _lowerCAmelCase				=      self.get_dummy_inputs()
     _lowerCAmelCase				=      pipe(**_lowerCAmelCase		).images
     _lowerCAmelCase				=      image[0, -3:, -3:, -1]

     assert image.shape == (1, 128, 128, 3)
     _lowerCAmelCase				=      np.array([0.65863, 0.59425, 0.49326, 0.56313, 0.53875, 0.56627, 0.51065, 0.39777, 0.46330]		)

     assert np.abs(image_slice.flatten() - expected_slice		).max() < 1E-2




 def 							_snake_case   (	self		)    ->							List[Any]:
     _lowerCAmelCase				=      OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint			,     provider="CPUExecutionProvider"		)
     _lowerCAmelCase				=      LMSDiscreteScheduler.from_config(pipe.scheduler.config		)
     pipe.set_progress_bar_config(disable=_lowerCAmelCase		)

     _lowerCAmelCase				=      self.get_dummy_inputs()
     _lowerCAmelCase				=      pipe(**_lowerCAmelCase		).images
     _lowerCAmelCase				=      image[0, -3:, -3:, -1]

     assert image.shape == (1, 128, 128, 3)
     _lowerCAmelCase				=      np.array([0.53755, 0.60786, 0.47402, 0.49488, 0.51869, 0.49819, 0.47985, 0.38957, 0.44279]		)

     assert np.abs(image_slice.flatten() - expected_slice		).max() < 1E-2




 def 							_snake_case   (	self		)    ->							Dict:
     _lowerCAmelCase				=      OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint			,     provider="CPUExecutionProvider"		)
     _lowerCAmelCase				=      EulerDiscreteScheduler.from_config(pipe.scheduler.config		)
     pipe.set_progress_bar_config(disable=_lowerCAmelCase		)

     _lowerCAmelCase				=      self.get_dummy_inputs()
     _lowerCAmelCase				=      pipe(**_lowerCAmelCase		).images
     _lowerCAmelCase				=      image[0, -3:, -3:, -1]

     assert image.shape == (1, 128, 128, 3)
     _lowerCAmelCase				=      np.array([0.53755, 0.60786, 0.47402, 0.49488, 0.51869, 0.49819, 0.47985, 0.38957, 0.44279]		)

     assert np.abs(image_slice.flatten() - expected_slice		).max() < 1E-2




 def 							_snake_case   (	self		)    ->							int:
     _lowerCAmelCase				=      OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint			,     provider="CPUExecutionProvider"		)
     _lowerCAmelCase				=      EulerAncestralDiscreteScheduler.from_config(pipe.scheduler.config		)
     pipe.set_progress_bar_config(disable=_lowerCAmelCase		)

     _lowerCAmelCase				=      self.get_dummy_inputs()
     _lowerCAmelCase				=      pipe(**_lowerCAmelCase		).images
     _lowerCAmelCase				=      image[0, -3:, -3:, -1]

     assert image.shape == (1, 128, 128, 3)
     _lowerCAmelCase				=      np.array([0.53817, 0.60812, 0.47384, 0.49530, 0.51894, 0.49814, 0.47984, 0.38958, 0.44271]		)

     assert np.abs(image_slice.flatten() - expected_slice		).max() < 1E-2




 def 							_snake_case   (	self		)    ->							Any:
     _lowerCAmelCase				=      OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint			,     provider="CPUExecutionProvider"		)
     _lowerCAmelCase				=      DPMSolverMultistepScheduler.from_config(pipe.scheduler.config		)
     pipe.set_progress_bar_config(disable=_lowerCAmelCase		)

     _lowerCAmelCase				=      self.get_dummy_inputs()
     _lowerCAmelCase				=      pipe(**_lowerCAmelCase		).images
     _lowerCAmelCase				=      image[0, -3:, -3:, -1]

     assert image.shape == (1, 128, 128, 3)
     _lowerCAmelCase				=      np.array([0.53895, 0.60808, 0.47933, 0.49608, 0.51886, 0.49950, 0.48053, 0.38957, 0.44200]		)

     assert np.abs(image_slice.flatten() - expected_slice		).max() < 1E-2




 def 							_snake_case   (	self		)    ->							str:
     _lowerCAmelCase				=      OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint			,     provider="CPUExecutionProvider"		)
     pipe.set_progress_bar_config(disable=_lowerCAmelCase		)

     _lowerCAmelCase				=      self.get_dummy_inputs()
     _lowerCAmelCase				=      3 * [inputs["prompt"]]

     # forward
     _lowerCAmelCase				=      pipe(**_lowerCAmelCase		)
     _lowerCAmelCase				=      output.images[0, -3:, -3:, -1]

     _lowerCAmelCase				=      self.get_dummy_inputs()
     _lowerCAmelCase				=      3 * [inputs.pop("prompt"		)]

     _lowerCAmelCase				=      pipe.tokenizer(
         _lowerCAmelCase			,     padding="max_length"			,     max_length=pipe.tokenizer.model_max_length			,     truncation=_lowerCAmelCase			,     return_tensors="np"			,     )
     _lowerCAmelCase				=      text_inputs["input_ids"]

     _lowerCAmelCase				=      pipe.text_encoder(input_ids=text_inputs.astype(np.intaa		)		)[0]

     _lowerCAmelCase				=      prompt_embeds

     # forward
     _lowerCAmelCase				=      pipe(**_lowerCAmelCase		)
     _lowerCAmelCase				=      output.images[0, -3:, -3:, -1]

     assert np.abs(image_slice_a.flatten() - image_slice_a.flatten()		).max() < 1E-4





 def 							_snake_case   (	self		)    ->							List[str]:
     _lowerCAmelCase				=      OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint			,     provider="CPUExecutionProvider"		)
     pipe.set_progress_bar_config(disable=_lowerCAmelCase		)

     _lowerCAmelCase				=      self.get_dummy_inputs()
     _lowerCAmelCase				=      3 * ["this is a negative prompt"]
     _lowerCAmelCase				=      negative_prompt
     _lowerCAmelCase				=      3 * [inputs["prompt"]]

     # forward
     _lowerCAmelCase				=      pipe(**_lowerCAmelCase		)
     _lowerCAmelCase				=      output.images[0, -3:, -3:, -1]

     _lowerCAmelCase				=      self.get_dummy_inputs()
     _lowerCAmelCase				=      3 * [inputs.pop("prompt"		)]

     _lowerCAmelCase				=      []
     for p in [prompt, negative_prompt]:
         _lowerCAmelCase				=      pipe.tokenizer(
             _lowerCAmelCase			,     padding="max_length"			,     max_length=pipe.tokenizer.model_max_length			,     truncation=_lowerCAmelCase			,     return_tensors="np"			,     )
         _lowerCAmelCase				=      text_inputs["input_ids"]

         embeds.append(pipe.text_encoder(input_ids=text_inputs.astype(np.intaa		)		)[0]		)

     _lowerCAmelCase			,			_lowerCAmelCase				=      embeds

     # forward
     _lowerCAmelCase				=      pipe(**_lowerCAmelCase		)
     _lowerCAmelCase				=      output.images[0, -3:, -3:, -1]

     assert np.abs(image_slice_a.flatten() - image_slice_a.flatten()		).max() < 1E-4







@nightly
@require_onnxruntime
@require_torch_gpu
class    lowerCAmelCase_		(		unittest.TestCase		):




 @property
 def 							_snake_case   (	self		)    ->							Tuple:
     return (
         "CUDAExecutionProvider",
         {
             "gpu_mem_limit": "15000000000",  # 15GB
             "arena_extend_strategy": "kSameAsRequested",
         },
     )




 @property
 def 							_snake_case   (	self		)    ->							List[str]:
     _lowerCAmelCase				=      ort.SessionOptions()
     _lowerCAmelCase				=      False
     return options




 def 							_snake_case   (	self		)    ->							Dict:
     # using the PNDM scheduler by default
     _lowerCAmelCase				=      OnnxStableDiffusionPipeline.from_pretrained(
         "CompVis/stable-diffusion-v1-4"			,     revision="onnx"			,     safety_checker=_lowerCAmelCase			,     feature_extractor=_lowerCAmelCase			,     provider=self.gpu_provider			,     sess_options=self.gpu_options			,     )
     sd_pipe.set_progress_bar_config(disable=_lowerCAmelCase		)

     _lowerCAmelCase				=      "A painting of a squirrel eating a burger"
     np.random.seed(0		)
     _lowerCAmelCase				=      sd_pipe([prompt]			,     guidance_scale=6.0			,     num_inference_steps=10			,     output_type="np"		)
     _lowerCAmelCase				=      output.images

     _lowerCAmelCase				=      image[0, -3:, -3:, -1]

     assert image.shape == (1, 512, 512, 3)
     _lowerCAmelCase				=      np.array([0.0452, 0.0390, 0.0087, 0.0350, 0.0617, 0.0364, 0.0544, 0.0523, 0.0720]		)

     assert np.abs(image_slice.flatten() - expected_slice		).max() < 1E-3




 def 							_snake_case   (	self		)    ->							int:
     _lowerCAmelCase				=      DDIMScheduler.from_pretrained(
         "runwayml/stable-diffusion-v1-5"			,     subfolder="scheduler"			,     revision="onnx"		)
     _lowerCAmelCase				=      OnnxStableDiffusionPipeline.from_pretrained(
         "runwayml/stable-diffusion-v1-5"			,     revision="onnx"			,     scheduler=_lowerCAmelCase			,     safety_checker=_lowerCAmelCase			,     feature_extractor=_lowerCAmelCase			,     provider=self.gpu_provider			,     sess_options=self.gpu_options			,     )
     sd_pipe.set_progress_bar_config(disable=_lowerCAmelCase		)

     _lowerCAmelCase				=      "open neural network exchange"
     _lowerCAmelCase				=      np.random.RandomState(0		)
     _lowerCAmelCase				=      sd_pipe([prompt]			,     guidance_scale=7.5			,     num_inference_steps=10			,     generator=_lowerCAmelCase			,     output_type="np"		)
     _lowerCAmelCase				=      output.images
     _lowerCAmelCase				=      image[0, -3:, -3:, -1]

     assert image.shape == (1, 512, 512, 3)
     _lowerCAmelCase				=      np.array([0.2867, 0.1974, 0.1481, 0.7294, 0.7251, 0.6667, 0.4194, 0.5642, 0.6486]		)

     assert np.abs(image_slice.flatten() - expected_slice		).max() < 1E-3




 def 							_snake_case   (	self		)    ->							List[Any]:
     _lowerCAmelCase				=      LMSDiscreteScheduler.from_pretrained(
         "runwayml/stable-diffusion-v1-5"			,     subfolder="scheduler"			,     revision="onnx"		)
     _lowerCAmelCase				=      OnnxStableDiffusionPipeline.from_pretrained(
         "runwayml/stable-diffusion-v1-5"			,     revision="onnx"			,     scheduler=_lowerCAmelCase			,     safety_checker=_lowerCAmelCase			,     feature_extractor=_lowerCAmelCase			,     provider=self.gpu_provider			,     sess_options=self.gpu_options			,     )
     sd_pipe.set_progress_bar_config(disable=_lowerCAmelCase		)

     _lowerCAmelCase				=      "open neural network exchange"
     _lowerCAmelCase				=      np.random.RandomState(0		)
     _lowerCAmelCase				=      sd_pipe([prompt]			,     guidance_scale=7.5			,     num_inference_steps=10			,     generator=_lowerCAmelCase			,     output_type="np"		)
     _lowerCAmelCase				=      output.images
     _lowerCAmelCase				=      image[0, -3:, -3:, -1]

     assert image.shape == (1, 512, 512, 3)
     _lowerCAmelCase				=      np.array([0.2306, 0.1959, 0.1593, 0.6549, 0.6394, 0.5408, 0.5065, 0.6010, 0.6161]		)

     assert np.abs(image_slice.flatten() - expected_slice		).max() < 1E-3




 def 							_snake_case   (	self		)    ->							Union[str, Any]:
     _lowerCAmelCase				=      0

     def test_callback_fn(_lowerCAmelCase			,     _lowerCAmelCase			,     _lowerCAmelCase		) -> None:
         _lowerCAmelCase				=      True
         nonlocal number_of_steps
         number_of_steps += 1
         if step == 0:
             assert latents.shape == (1, 4, 64, 64)
             _lowerCAmelCase				=      latents[0, -3:, -3:, -1]
             _lowerCAmelCase				=      np.array(
                 [-0.6772, -0.3835, -1.2456, 0.1905, -1.0974, 0.6967, -1.9353, 0.0178, 1.0167]		)

             assert np.abs(latents_slice.flatten() - expected_slice		).max() < 1E-3
         elif step == 5:
             assert latents.shape == (1, 4, 64, 64)
             _lowerCAmelCase				=      latents[0, -3:, -3:, -1]
             _lowerCAmelCase				=      np.array(
                 [-0.3351, 0.2241, -0.1837, -0.2325, -0.6577, 0.3393, -0.0241, 0.5899, 1.3875]		)

             assert np.abs(latents_slice.flatten() - expected_slice		).max() < 1E-3

     _lowerCAmelCase				=      False

     _lowerCAmelCase				=      OnnxStableDiffusionPipeline.from_pretrained(
         "runwayml/stable-diffusion-v1-5"			,     revision="onnx"			,     safety_checker=_lowerCAmelCase			,     feature_extractor=_lowerCAmelCase			,     provider=self.gpu_provider			,     sess_options=self.gpu_options			,     )
     pipe.set_progress_bar_config(disable=_lowerCAmelCase		)

     _lowerCAmelCase				=      "Andromeda galaxy in a bottle"

     _lowerCAmelCase				=      np.random.RandomState(0		)
     pipe(
         prompt=_lowerCAmelCase			,     num_inference_steps=5			,     guidance_scale=7.5			,     generator=_lowerCAmelCase			,     callback=_lowerCAmelCase			,     callback_steps=1			,     )
     assert test_callback_fn.has_been_called
     assert number_of_steps == 6





 def 							_snake_case   (	self		)    ->							Union[str, Any]:
     _lowerCAmelCase				=      OnnxStableDiffusionPipeline.from_pretrained(
         "runwayml/stable-diffusion-v1-5"			,     revision="onnx"			,     safety_checker=_lowerCAmelCase			,     feature_extractor=_lowerCAmelCase			,     provider=self.gpu_provider			,     sess_options=self.gpu_options			,     )
     assert isinstance(_lowerCAmelCase			,     _lowerCAmelCase		)
     assert pipe.safety_checker is None

     _lowerCAmelCase				=      pipe("example prompt"			,     num_inference_steps=2		).images[0]
     assert image is not None

     # check that there's no error when saving a pipeline with one of the models being None
     with tempfile.TemporaryDirectory() as tmpdirname:
         pipe.save_pretrained(_lowerCAmelCase		)
         _lowerCAmelCase				=      OnnxStableDiffusionPipeline.from_pretrained(_lowerCAmelCase		)

     # sanity check that the pipeline still works
     assert pipe.safety_checker is None
     _lowerCAmelCase				=      pipe("example prompt"			,     num_inference_steps=2		).images[0]
     assert image is not None









'''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


_SCREAMING_SNAKE_CASE	 =							logging.get_logger(__name__)

_SCREAMING_SNAKE_CASE	 =							"▁"

_SCREAMING_SNAKE_CASE	 =							{"vocab_file": "sentencepiece.bpe.model"}

_SCREAMING_SNAKE_CASE	 =							{
    "vocab_file": {
        "facebook/xglm-564M": "https://huggingface.co/facebook/xglm-564M/resolve/main/sentencepiece.bpe.model",
    }
}

_SCREAMING_SNAKE_CASE	 =							{
    "facebook/xglm-564M": 20_48,
}

class    lowerCAmelCase_		(		__magic_name__		):
 __lowerCamelCase						:							int         =					VOCAB_FILES_NAMES
 __lowerCamelCase						:							Optional[int]         =					PRETRAINED_VOCAB_FILES_MAP
 __lowerCamelCase						:							Tuple         =					PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
 __lowerCamelCase						:							str         =					["input_ids", "attention_mask"]




 def __init__(	self			,     _lowerCAmelCase			,     _lowerCAmelCase="<s>"			,     _lowerCAmelCase="</s>"			,     _lowerCAmelCase="</s>"			,     _lowerCAmelCase="<s>"			,     _lowerCAmelCase="<unk>"			,     _lowerCAmelCase="<pad>"			,     _lowerCAmelCase = None			,     **_lowerCAmelCase			,     )    ->							None:
     _lowerCAmelCase				=      {} if sp_model_kwargs is None else sp_model_kwargs

     # Compatibility with the original tokenizer
     _lowerCAmelCase				=      7
     _lowerCAmelCase				=      [f'''<madeupword{i}>''' for i in range(self.num_madeup_words		)]

     _lowerCAmelCase				=      kwargs.get("additional_special_tokens"			,     []		)
     kwargs["additional_special_tokens"] += [
         word for word in madeup_words if word not in kwargs["additional_special_tokens"]
     ]

     super().__init__(
         bos_token=_lowerCAmelCase			,     eos_token=_lowerCAmelCase			,     unk_token=_lowerCAmelCase			,     sep_token=_lowerCAmelCase			,     cls_token=_lowerCAmelCase			,     pad_token=_lowerCAmelCase			,     sp_model_kwargs=self.sp_model_kwargs			,     **_lowerCAmelCase			,     )

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

     # Original fairseq vocab and spm vocab must be "aligned":
     # Vocab    |    0    |    1    |   2    |    3    |  4  |  5  |  6  |   7   |   8   |  9
     # -------- | ------- | ------- | ------ | ------- | --- | --- | --- | ----- | ----- | ----
     # fairseq  | '<s>'   | '<pad>' | '</s>' | '<unk>' | ',' | '.' | '▁' | 's'   | '▁de' | '-'
     # spm      | '<unk>' | '<s>'   | '</s>' | ','     | '.' | '▁' | 's' | '▁de' | '-'   | '▁a'

     # The first "real" token "," has position 4 in the original fairseq vocab and position 3 in the spm vocab
     _lowerCAmelCase				=      1

     # Mimic fairseq token-to-id alignment for the first 4 token
     _lowerCAmelCase				=      {"<s>": 0, "<pad>": 1, "</s>": 2, "<unk>": 3}

     _lowerCAmelCase				=      len(self.sp_model		)
     _lowerCAmelCase				=      {f'''<madeupword{i}>''': sp_size + i + self.fairseq_offset for i in range(self.num_madeup_words		)}
     self.fairseq_tokens_to_ids.update(_lowerCAmelCase		)

     _lowerCAmelCase				=      {v: k for k, v in self.fairseq_tokens_to_ids.items()}




 def __getstate__(	self		)    ->							List[str]:
     _lowerCAmelCase				=      self.__dict__.copy()
     _lowerCAmelCase				=      None
     _lowerCAmelCase				=      self.sp_model.serialized_model_proto()
     return state




 def __setstate__(	self			,     _lowerCAmelCase		)    ->							Optional[int]:
     _lowerCAmelCase				=      d

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

     _lowerCAmelCase				=      spm.SentencePieceProcessor(**self.sp_model_kwargs		)
     self.sp_model.LoadFromSerializedProto(self.sp_model_proto		)




 def 							_snake_case   (	self			,     _lowerCAmelCase			,     _lowerCAmelCase = None		)    ->							List[int]:

     if token_ids_a is None:
         return [self.sep_token_id] + token_ids_a
     _lowerCAmelCase				=      [self.sep_token_id]
     return sep + token_ids_a + sep + sep + token_ids_a




 def 							_snake_case   (	self			,     _lowerCAmelCase			,     _lowerCAmelCase = None			,     _lowerCAmelCase = False		)    ->							List[int]:

     if already_has_special_tokens:
         return super().get_special_tokens_mask(
             token_ids_a=_lowerCAmelCase			,     token_ids_a=_lowerCAmelCase			,     already_has_special_tokens=_lowerCAmelCase		)

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




 def 							_snake_case   (	self			,     _lowerCAmelCase			,     _lowerCAmelCase = None		)    ->							List[int]:
     _lowerCAmelCase				=      [self.sep_token_id]

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




 @property
 def 							_snake_case   (	self		)    ->							str:
     return len(self.sp_model		) + self.fairseq_offset + self.num_madeup_words




 def 							_snake_case   (	self		)    ->							Any:
     _lowerCAmelCase				=      {self.convert_ids_to_tokens(_lowerCAmelCase		): i for i in range(self.vocab_size		)}
     vocab.update(self.added_tokens_encoder		)
     return vocab




 def 							_snake_case   (	self			,     _lowerCAmelCase		)    ->							List[str]:
     return self.sp_model.encode(_lowerCAmelCase			,     out_type=_lowerCAmelCase		)




 def 							_snake_case   (	self			,     _lowerCAmelCase		)    ->							List[str]:
     if token in self.fairseq_tokens_to_ids:
         return self.fairseq_tokens_to_ids[token]
     _lowerCAmelCase				=      self.sp_model.PieceToId(_lowerCAmelCase		)

     # Need to return unknown token if the SP model returned 0
     return spm_id + self.fairseq_offset if spm_id else self.unk_token_id




 def 							_snake_case   (	self			,     _lowerCAmelCase		)    ->							List[Any]:
     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 							_snake_case   (	self			,     _lowerCAmelCase		)    ->							Union[str, Any]:
     _lowerCAmelCase				=      "".join(_lowerCAmelCase		).replace(_lowerCAmelCase			,     " "		).strip()
     return out_string





 def 							_snake_case   (	self			,     _lowerCAmelCase			,     _lowerCAmelCase = None		)    ->							Tuple[str]:
     if not os.path.isdir(_lowerCAmelCase		):
         logger.error(f'''Vocabulary path ({save_directory}) should be a directory'''		)
         return
     _lowerCAmelCase				=      os.path.join(
         _lowerCAmelCase			,     (filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"]		)

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

     return (out_vocab_file,)


