


'''simple docstring'''

# This model implementation is heavily inspired by https://github.com/haofanwang/ControlNet-for-Diffusers/

import gc
import random
import tempfile
import unittest

import numpy as np
import torch
from PIL import Image
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    ControlNetModel,
    DDIMScheduler,
    StableDiffusionControlNetImgaImgPipeline,
    UNetaDConditionModel,
)
from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_controlnet import MultiControlNetModel
from diffusers.utils import floats_tensor, load_image, load_numpy, randn_tensor, slow, torch_device
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import (
    IMAGE_TO_IMAGE_IMAGE_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_PARAMS,
)
from ..test_pipelines_common import (
    PipelineKarrasSchedulerTesterMixin,
    PipelineLatentTesterMixin,
    PipelineTesterMixin,
)


enable_full_determinism()





class      snake_case    (    lowercase			,						lowercase			,						lowercase			,						unittest.TestCase			):





  """simple docstring"""




  _lowerCamelCase		    =  StableDiffusionControlNetImgaImgPipeline
  _lowerCamelCase		    =  TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {"height", "width"}
  _lowerCamelCase		    =  TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
  _lowerCamelCase		    =  IMAGE_TO_IMAGE_IMAGE_PARAMS.union({"control_image"}			)
  _lowerCamelCase		    =  IMAGE_TO_IMAGE_IMAGE_PARAMS






  def   snake_case		(    self     ):







   """simple docstring"""
   torch.manual_seed(0     )
   lowerCamelCase_      =  UNetaDConditionModel(
       block_out_channels=(32, 64)			,  layers_per_block=2			,  sample_size=32			,  in_channels=4			,  out_channels=4			,  down_block_types=("DownBlock2D", "CrossAttnDownBlock2D")			,  up_block_types=("CrossAttnUpBlock2D", "UpBlock2D")			,  cross_attention_dim=32			,  )
   torch.manual_seed(0     )
   lowerCamelCase_      =  ControlNetModel(
       block_out_channels=(32, 64)			,  layers_per_block=2			,  in_channels=4			,  down_block_types=("DownBlock2D", "CrossAttnDownBlock2D")			,  cross_attention_dim=32			,  conditioning_embedding_out_channels=(16, 32)			,  )
   torch.manual_seed(0     )
   lowerCamelCase_      =  DDIMScheduler(
       beta_start=0.00_085			,  beta_end=0.012			,  beta_schedule="scaled_linear"			,  clip_sample=UpperCamelCase			,  set_alpha_to_one=UpperCamelCase			,  )
   torch.manual_seed(0     )
   lowerCamelCase_      =  AutoencoderKL(
       block_out_channels=[32, 64]			,  in_channels=3			,  out_channels=3			,  down_block_types=["DownEncoderBlock2D", "DownEncoderBlock2D"]			,  up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D"]			,  latent_channels=4			,  )
   torch.manual_seed(0     )
   lowerCamelCase_      =  CLIPTextConfig(
       bos_token_id=0			,  eos_token_id=2			,  hidden_size=32			,  intermediate_size=37			,  layer_norm_eps=1e-05			,  num_attention_heads=4			,  num_hidden_layers=5			,  pad_token_id=1			,  vocab_size=1000			,  )
   lowerCamelCase_      =  CLIPTextModel(UpperCamelCase     )
   lowerCamelCase_      =  CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"     )

   lowerCamelCase_      =  {
       "unet": unet,
       "controlnet": controlnet,
       "scheduler": scheduler,
       "vae": vae,
       "text_encoder": text_encoder,
       "tokenizer": tokenizer,
       "safety_checker": None,
       "feature_extractor": None,
   }
   return components






  def   snake_case		(    self			,  UpperCamelCase			,  UpperCamelCase=0     ):







   """simple docstring"""
   if str(UpperCamelCase     ).startswith("mps"     ):
    lowerCamelCase_      =  torch.manual_seed(UpperCamelCase     )
   else:
    lowerCamelCase_      =  torch.Generator(device=UpperCamelCase     ).manual_seed(UpperCamelCase     )

   lowerCamelCase_      =  2
   lowerCamelCase_      =  randn_tensor(
       (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor)			,  generator=UpperCamelCase			,  device=torch.device(UpperCamelCase     )			,  )
   lowerCamelCase_      =  floats_tensor(control_image.shape			,  rng=random.Random(UpperCamelCase     )     ).to(UpperCamelCase     )
   lowerCamelCase_      =  image.cpu().permute(0			,  2			,  3			,  1     )[0]
   lowerCamelCase_      =  Image.fromarray(np.uinta(UpperCamelCase     )     ).convert("RGB"     ).resize((64, 64)     )
   lowerCamelCase_      =  {
       "prompt": "A painting of a squirrel eating a burger",
       "generator": generator,
       "num_inference_steps": 2,
       "guidance_scale": 6.0,
       "output_type": "numpy",
       "image": image,
       "control_image": control_image,
   }

   return inputs






  def   snake_case		(    self     ):







   """simple docstring"""
   return self._test_attention_slicing_forward_pass(expected_max_diff=2e-3     )






  @unittest.skipIf(
      torch_device != "cuda" or not is_xformers_available()			,  reason="XFormers attention is only available with CUDA and `xformers` installed"			,  )
  def   snake_case		(    self     ):







   """simple docstring"""
   self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2e-3     )







  def   snake_case		(    self     ):







   """simple docstring"""
   self._test_inference_batch_single_identical(expected_max_diff=2e-3     )





class      snake_case    (    lowercase			,						lowercase			,						unittest.TestCase			):





  """simple docstring"""




  _lowerCamelCase		    =  StableDiffusionControlNetImgaImgPipeline
  _lowerCamelCase		    =  TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {"height", "width"}
  _lowerCamelCase		    =  TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
  _lowerCamelCase		    =  frozenset([]			)  # TO_DO: add image_params once refactored VaeImageProcessor.preprocess






  def   snake_case		(    self     ):







   """simple docstring"""
   torch.manual_seed(0     )
   lowerCamelCase_      =  UNetaDConditionModel(
       block_out_channels=(32, 64)			,  layers_per_block=2			,  sample_size=32			,  in_channels=4			,  out_channels=4			,  down_block_types=("DownBlock2D", "CrossAttnDownBlock2D")			,  up_block_types=("CrossAttnUpBlock2D", "UpBlock2D")			,  cross_attention_dim=32			,  )
   torch.manual_seed(0     )

   def init_weights(UpperCamelCase     ):
    if isinstance(UpperCamelCase			,  torch.nn.Convad     ):
     torch.nn.init.normal(m.weight     )
     m.bias.data.fill_(1.0     )

   lowerCamelCase_      =  ControlNetModel(
       block_out_channels=(32, 64)			,  layers_per_block=2			,  in_channels=4			,  down_block_types=("DownBlock2D", "CrossAttnDownBlock2D")			,  cross_attention_dim=32			,  conditioning_embedding_out_channels=(16, 32)			,  )
   controlneta.controlnet_down_blocks.apply(UpperCamelCase     )

   torch.manual_seed(0     )
   lowerCamelCase_      =  ControlNetModel(
       block_out_channels=(32, 64)			,  layers_per_block=2			,  in_channels=4			,  down_block_types=("DownBlock2D", "CrossAttnDownBlock2D")			,  cross_attention_dim=32			,  conditioning_embedding_out_channels=(16, 32)			,  )
   controlneta.controlnet_down_blocks.apply(UpperCamelCase     )

   torch.manual_seed(0     )
   lowerCamelCase_      =  DDIMScheduler(
       beta_start=0.00_085			,  beta_end=0.012			,  beta_schedule="scaled_linear"			,  clip_sample=UpperCamelCase			,  set_alpha_to_one=UpperCamelCase			,  )
   torch.manual_seed(0     )
   lowerCamelCase_      =  AutoencoderKL(
       block_out_channels=[32, 64]			,  in_channels=3			,  out_channels=3			,  down_block_types=["DownEncoderBlock2D", "DownEncoderBlock2D"]			,  up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D"]			,  latent_channels=4			,  )
   torch.manual_seed(0     )
   lowerCamelCase_      =  CLIPTextConfig(
       bos_token_id=0			,  eos_token_id=2			,  hidden_size=32			,  intermediate_size=37			,  layer_norm_eps=1e-05			,  num_attention_heads=4			,  num_hidden_layers=5			,  pad_token_id=1			,  vocab_size=1000			,  )
   lowerCamelCase_      =  CLIPTextModel(UpperCamelCase     )
   lowerCamelCase_      =  CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"     )

   lowerCamelCase_      =  MultiControlNetModel([controlneta, controlneta]     )

   lowerCamelCase_      =  {
       "unet": unet,
       "controlnet": controlnet,
       "scheduler": scheduler,
       "vae": vae,
       "text_encoder": text_encoder,
       "tokenizer": tokenizer,
       "safety_checker": None,
       "feature_extractor": None,
   }
   return components






  def   snake_case		(    self			,  UpperCamelCase			,  UpperCamelCase=0     ):







   """simple docstring"""
   if str(UpperCamelCase     ).startswith("mps"     ):
    lowerCamelCase_      =  torch.manual_seed(UpperCamelCase     )
   else:
    lowerCamelCase_      =  torch.Generator(device=UpperCamelCase     ).manual_seed(UpperCamelCase     )

   lowerCamelCase_      =  2

   lowerCamelCase_      =  [
       randn_tensor(
           (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor)			,  generator=UpperCamelCase			,  device=torch.device(UpperCamelCase     )			,  ),
       randn_tensor(
           (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor)			,  generator=UpperCamelCase			,  device=torch.device(UpperCamelCase     )			,  ),
   ]

   lowerCamelCase_      =  floats_tensor(control_image[0].shape			,  rng=random.Random(UpperCamelCase     )     ).to(UpperCamelCase     )
   lowerCamelCase_      =  image.cpu().permute(0			,  2			,  3			,  1     )[0]
   lowerCamelCase_      =  Image.fromarray(np.uinta(UpperCamelCase     )     ).convert("RGB"     ).resize((64, 64)     )
   lowerCamelCase_      =  {
       "prompt": "A painting of a squirrel eating a burger",
       "generator": generator,
       "num_inference_steps": 2,
       "guidance_scale": 6.0,
       "output_type": "numpy",
       "image": image,
       "control_image": control_image,
   }

   return inputs






  def   snake_case		(    self     ):







   """simple docstring"""
   lowerCamelCase_      =  self.get_dummy_components()
   lowerCamelCase_      =  self.pipeline_class(**UpperCamelCase     )
   pipe.to(UpperCamelCase     )

   lowerCamelCase_      =  10.0
   lowerCamelCase_      =  4

   lowerCamelCase_      =  self.get_dummy_inputs(UpperCamelCase     )
   lowerCamelCase_      =  steps
   lowerCamelCase_      =  scale
   lowerCamelCase_      =  pipe(**UpperCamelCase     )[0]

   lowerCamelCase_      =  self.get_dummy_inputs(UpperCamelCase     )
   lowerCamelCase_      =  steps
   lowerCamelCase_      =  scale
   lowerCamelCase_      =  pipe(**UpperCamelCase			,  control_guidance_start=0.1			,  control_guidance_end=0.2     )[0]

   lowerCamelCase_      =  self.get_dummy_inputs(UpperCamelCase     )
   lowerCamelCase_      =  steps
   lowerCamelCase_      =  scale
   lowerCamelCase_      =  pipe(**UpperCamelCase			,  control_guidance_start=[0.1, 0.3]			,  control_guidance_end=[0.2, 0.7]     )[0]

   lowerCamelCase_      =  self.get_dummy_inputs(UpperCamelCase     )
   lowerCamelCase_      =  steps
   lowerCamelCase_      =  scale
   lowerCamelCase_      =  pipe(**UpperCamelCase			,  control_guidance_start=0.4			,  control_guidance_end=[0.5, 0.8]     )[0]

   # make sure that all outputs are different
   assert np.sum(np.abs(output_a - output_a     )     ) > 1e-3
   assert np.sum(np.abs(output_a - output_a     )     ) > 1e-3
   assert np.sum(np.abs(output_a - output_a     )     ) > 1e-3






  def   snake_case		(    self     ):







   """simple docstring"""
   return self._test_attention_slicing_forward_pass(expected_max_diff=2e-3     )






  @unittest.skipIf(
      torch_device != "cuda" or not is_xformers_available()			,  reason="XFormers attention is only available with CUDA and `xformers` installed"			,  )
  def   snake_case		(    self     ):







   """simple docstring"""
   self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2e-3     )






  def   snake_case		(    self     ):







   """simple docstring"""
   self._test_inference_batch_single_identical(expected_max_diff=2e-3     )







  def   snake_case		(    self     ):







   """simple docstring"""
   lowerCamelCase_      =  self.get_dummy_components()
   lowerCamelCase_      =  self.pipeline_class(**UpperCamelCase     )
   pipe.to(UpperCamelCase     )
   pipe.set_progress_bar_config(disable=UpperCamelCase     )
   with tempfile.TemporaryDirectory() as tmpdir:
    try:
     # save_pretrained is not implemented for Multi-ControlNet
     pipe.save_pretrained(UpperCamelCase     )
    except NotImplementedError:
     pass





@slow
@require_torch_gpu
class      snake_case    (    unittest.TestCase			):





  """simple docstring"""




  def   snake_case		(    self     ):







   """simple docstring"""
   super().tearDown()
   gc.collect()
   torch.cuda.empty_cache()







  def   snake_case		(    self     ):







   """simple docstring"""
   lowerCamelCase_      =  ControlNetModel.from_pretrained("lllyasviel/sd-controlnet-canny"     )

   lowerCamelCase_      =  StableDiffusionControlNetImgaImgPipeline.from_pretrained(
       "runwayml/stable-diffusion-v1-5"			,  safety_checker=UpperCamelCase			,  controlnet=UpperCamelCase     )
   pipe.enable_model_cpu_offload()
   pipe.set_progress_bar_config(disable=UpperCamelCase     )

   lowerCamelCase_      =  torch.Generator(device="cpu"     ).manual_seed(0     )
   lowerCamelCase_      =  "evil space-punk bird"
   lowerCamelCase_      =  load_image(
       "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/bird_canny.png"     ).resize((512, 512)     )
   lowerCamelCase_      =  load_image(
       "https://huggingface.co/lllyasviel/sd-controlnet-canny/resolve/main/images/bird.png"     ).resize((512, 512)     )

   lowerCamelCase_      =  pipe(
       UpperCamelCase			,  UpperCamelCase			,  control_image=UpperCamelCase			,  generator=UpperCamelCase			,  output_type="np"			,  num_inference_steps=50			,  strength=0.6			,  )

   lowerCamelCase_      =  output.images[0]

   assert image.shape == (512, 512, 3)

   lowerCamelCase_      =  load_numpy(
       "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/img2img.npy"     )

   assert np.abs(expected_image - image     ).max() < 9e-2







'''simple docstring'''

import os
import unicodedata
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 SPIECE_UNDERLINE, logging


a_  :				Any						= logging.get_logger(__name__)

a_  :				Optional[Any]						= {"""vocab_file""": """spiece.model"""}

a_  :				Tuple						= {
    """vocab_file""": {
        """TsinghuaAI/CPM-Generate""": """https://huggingface.co/TsinghuaAI/CPM-Generate/resolve/main/spiece.model""",
    }
}





class      snake_case    (    lowercase			):





  """simple docstring"""




  def __init__(    self			,  UpperCamelCase			,  UpperCamelCase=False			,  UpperCamelCase=True			,  UpperCamelCase=False			,  UpperCamelCase="<s>"			,  UpperCamelCase="</s>"			,  UpperCamelCase="<unk>"			,  UpperCamelCase="<sep>"			,  UpperCamelCase="<pad>"			,  UpperCamelCase="<cls>"			,  UpperCamelCase="<mask>"			,  UpperCamelCase=["<eop>", "<eod>"]			,  UpperCamelCase = None			,  **UpperCamelCase			,  ):







   """simple docstring"""
   lowerCamelCase_      =  AddedToken(UpperCamelCase			,  lstrip=UpperCamelCase			,  rstrip=UpperCamelCase     ) if isinstance(UpperCamelCase			,  UpperCamelCase     ) else mask_token

   lowerCamelCase_      =  {} if sp_model_kwargs is None else sp_model_kwargs

   super().__init__(
       do_lower_case=UpperCamelCase			,  remove_space=UpperCamelCase			,  keep_accents=UpperCamelCase			,  bos_token=UpperCamelCase			,  eos_token=UpperCamelCase			,  unk_token=UpperCamelCase			,  sep_token=UpperCamelCase			,  pad_token=UpperCamelCase			,  cls_token=UpperCamelCase			,  mask_token=UpperCamelCase			,  additional_special_tokens=UpperCamelCase			,  sp_model_kwargs=self.sp_model_kwargs			,  **UpperCamelCase			,  )

   lowerCamelCase_      =  3

   lowerCamelCase_      =  do_lower_case
   lowerCamelCase_      =  remove_space
   lowerCamelCase_      =  keep_accents
   lowerCamelCase_      =  vocab_file

   lowerCamelCase_      =  spm.SentencePieceProcessor(**self.sp_model_kwargs     )
   self.sp_model.Load(UpperCamelCase     )

   try:
    import jieba
   except ModuleNotFoundError as error:
    raise error.__class__(
        "You need to install jieba to use CpmTokenizer or CpmTokenizerFast. "
        "See https://pypi.org/project/jieba/ for installation."     )
   lowerCamelCase_      =  jieba
   lowerCamelCase_      =  str.maketrans(" \n"			,  "\u2582\u2583"     )






  @property
  # Copied from transformers.models.xlnet.tokenization_xlnet.XLNetTokenizer.vocab_size
  def   snake_case		(    self     ):







   """simple docstring"""
   return len(self.sp_model     )






  def   snake_case		(    self     ):







   """simple docstring"""
   lowerCamelCase_      =  {self.convert_ids_to_tokens(UpperCamelCase     ): i for i in range(self.vocab_size     )}
   vocab.update(self.added_tokens_encoder     )
   return vocab






  def __getstate__(    self     ):







   """simple docstring"""
   lowerCamelCase_      =  self.__dict__.copy()
   lowerCamelCase_      =  None
   return state






  def __setstate__(    self			,  UpperCamelCase     ):







   """simple docstring"""
   lowerCamelCase_      =  d

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

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






  def   snake_case		(    self			,  UpperCamelCase     ):







   """simple docstring"""
   if self.remove_space:
    lowerCamelCase_      =  " ".join(inputs.strip().split()     )
   else:
    lowerCamelCase_      =  inputs
   lowerCamelCase_      =  outputs.replace("``"			,  "\""     ).replace("''"			,  "\""     )

   if not self.keep_accents:
    lowerCamelCase_      =  unicodedata.normalize("NFKD"			,  UpperCamelCase     )
    lowerCamelCase_      =  "".join([c for c in outputs if not unicodedata.combining(UpperCamelCase     )]     )
   if self.do_lower_case:
    lowerCamelCase_      =  outputs.lower()

   return outputs






  def   snake_case		(    self			,  UpperCamelCase     ):







   """simple docstring"""
   lowerCamelCase_      =  self.preprocess_text(UpperCamelCase     )
   lowerCamelCase_      =  self.sp_model.encode(UpperCamelCase			,  out_type=UpperCamelCase     )
   lowerCamelCase_      =  []
   for piece in pieces:
    if len(UpperCamelCase     ) > 1 and piece[-1] == str(","     ) and piece[-2].isdigit():
     lowerCamelCase_      =  self.sp_model.EncodeAsPieces(piece[:-1].replace(UpperCamelCase			,  ""     )     )
     if piece[0] != SPIECE_UNDERLINE and cur_pieces[0][0] == SPIECE_UNDERLINE:
      if len(cur_pieces[0]     ) == 1:
       lowerCamelCase_      =  cur_pieces[1:]
      else:
       lowerCamelCase_      =  cur_pieces[0][1:]
     cur_pieces.append(piece[-1]     )
     new_pieces.extend(UpperCamelCase     )
    else:
     new_pieces.append(UpperCamelCase     )

   return new_pieces






  def   snake_case		(    self			,  UpperCamelCase     ):







   """simple docstring"""
   return self.sp_model.PieceToId(UpperCamelCase     )






  def   snake_case		(    self			,  UpperCamelCase     ):







   """simple docstring"""
   return self.sp_model.IdToPiece(UpperCamelCase     )






  def   snake_case		(    self			,  UpperCamelCase     ):







   """simple docstring"""
   lowerCamelCase_      =  "".join(UpperCamelCase     ).replace(UpperCamelCase			,  " "     ).strip()
   return out_string






  def   snake_case		(    self			,  UpperCamelCase			,  UpperCamelCase = None     ):







   """simple docstring"""
   lowerCamelCase_      =  [self.sep_token_id]
   lowerCamelCase_      =  [self.cls_token_id]
   if token_ids_a is None:
    return token_ids_a + sep + cls
   return token_ids_a + sep + token_ids_a + sep + cls






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







   """simple docstring"""

   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 not None:
    return ([0] * len(UpperCamelCase     )) + [1] + ([0] * len(UpperCamelCase     )) + [1, 1]
   return ([0] * len(UpperCamelCase     )) + [1, 1]






  def   snake_case		(    self			,  UpperCamelCase			,  UpperCamelCase = None     ):







   """simple docstring"""
   lowerCamelCase_      =  [self.sep_token_id]
   lowerCamelCase_      =  [2]

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






  def   snake_case		(    self			,  UpperCamelCase			,  UpperCamelCase = None     ):







   """simple docstring"""
   if not os.path.isdir(UpperCamelCase     ):
    logger.error(f'''Vocabulary path ({save_directory}) should be a directory'''     )
    return
   lowerCamelCase_      =  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:
     lowerCamelCase_      =  self.sp_model.serialized_model_proto()
     fi.write(UpperCamelCase     )

   return (out_vocab_file,)







  def   snake_case		(    self			,  *UpperCamelCase			,  **UpperCamelCase     ):







   """simple docstring"""
   lowerCamelCase_      =  super()._decode(*UpperCamelCase			,  **UpperCamelCase     )
   lowerCamelCase_      =  text.replace(" "			,  ""     ).replace("\u2582"			,  " "     ).replace("\u2583"			,  "\n"     )
   return text



