





'''simple docstring'''






import gc
import unittest

import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTextModelWithProjection, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    DDPMScheduler,
    PriorTransformer,
    StableUnCLIPPipeline,
    UNetaDConditionModel,
)
from diffusers.pipelines.stable_diffusion.stable_unclip_image_normalizer import StableUnCLIPImageNormalizer
from diffusers.utils.testing_utils import enable_full_determinism, load_numpy, require_torch_gpu, slow, torch_device

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import (
    PipelineKarrasSchedulerTesterMixin,
    PipelineLatentTesterMixin,
    PipelineTesterMixin,
    assert_mean_pixel_difference,
)


enable_full_determinism()




class  UpperCAmelCase     (			snake_case_							,		snake_case_							,		snake_case_							,		unittest.TestCase   ):
      _lowercase:			Union[str, Any]						     =   StableUnCLIPPipeline
      _lowercase:			List[Any]						     =   TEXT_TO_IMAGE_PARAMS
      _lowercase:			Optional[Any]						     =   TEXT_TO_IMAGE_BATCH_PARAMS
      _lowercase:			Dict						     =   TEXT_TO_IMAGE_IMAGE_PARAMS
      _lowercase:			Dict						     =   TEXT_TO_IMAGE_IMAGE_PARAMS

      # TODO(will) Expected attn_bias.stride(1) == 0 to be true, but got false
      _lowercase:			List[str]						     =   False




      def 				lowercase__    (			self			: Optional[Any]  )				->      str:
            _lowerCAmelCase							     =							32
            _lowerCAmelCase							     =							embedder_hidden_size

            # prior components

            torch.manual_seed(0  )
            _lowerCAmelCase							     =							CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""  )

            torch.manual_seed(0  )
            _lowerCAmelCase							     =							CLIPTextModelWithProjection(
                CLIPTextConfig(
                    bos_token_id=0			,			eos_token_id=2			,			hidden_size=__snake_case			,			projection_dim=__snake_case			,			intermediate_size=37			,			layer_norm_eps=1E-0_5			,			num_attention_heads=4			,			num_hidden_layers=5			,			pad_token_id=1			,			vocab_size=10_00			,			)  )

            torch.manual_seed(0  )
            _lowerCAmelCase							     =							PriorTransformer(
                num_attention_heads=2			,			attention_head_dim=12			,			embedding_dim=__snake_case			,			num_layers=1			,			)

            torch.manual_seed(0  )
            _lowerCAmelCase							     =							DDPMScheduler(
                variance_type="""fixed_small_log"""			,			prediction_type="""sample"""			,			num_train_timesteps=10_00			,			clip_sample=__snake_case			,			clip_sample_range=5.0			,			beta_schedule="""squaredcos_cap_v2"""			,			)

            # regular denoising components

            torch.manual_seed(0  )
            _lowerCAmelCase							     =							StableUnCLIPImageNormalizer(embedding_dim=__snake_case  )
            _lowerCAmelCase							     =							DDPMScheduler(beta_schedule="""squaredcos_cap_v2"""  )

            torch.manual_seed(0  )
            _lowerCAmelCase							     =							CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""  )

            torch.manual_seed(0  )
            _lowerCAmelCase							     =							CLIPTextModel(
                CLIPTextConfig(
                    bos_token_id=0			,			eos_token_id=2			,			hidden_size=__snake_case			,			projection_dim=32			,			intermediate_size=37			,			layer_norm_eps=1E-0_5			,			num_attention_heads=4			,			num_hidden_layers=5			,			pad_token_id=1			,			vocab_size=10_00			,			)  )

            torch.manual_seed(0  )
            _lowerCAmelCase							     =							UNetaDConditionModel(
                sample_size=32			,			in_channels=4			,			out_channels=4			,			down_block_types=("""CrossAttnDownBlock2D""", """DownBlock2D""")			,			up_block_types=("""UpBlock2D""", """CrossAttnUpBlock2D""")			,			block_out_channels=(32, 64)			,			attention_head_dim=(2, 4)			,			class_embed_type="""projection"""			,			projection_class_embeddings_input_dim=embedder_projection_dim * 2			,			cross_attention_dim=__snake_case			,			layers_per_block=1			,			upcast_attention=__snake_case			,			use_linear_projection=__snake_case			,			)

            torch.manual_seed(0  )
            _lowerCAmelCase							     =							DDIMScheduler(
                beta_schedule="""scaled_linear"""			,			beta_start=0.0_00_85			,			beta_end=0.0_12			,			prediction_type="""v_prediction"""			,			set_alpha_to_one=__snake_case			,			steps_offset=1			,			)

            torch.manual_seed(0  )
            _lowerCAmelCase							     =							AutoencoderKL()

            _lowerCAmelCase							     =							{
                # prior components
                """prior_tokenizer""": prior_tokenizer,
                """prior_text_encoder""": prior_text_encoder,
                """prior""": prior,
                """prior_scheduler""": prior_scheduler,
                # image noising components
                """image_normalizer""": image_normalizer,
                """image_noising_scheduler""": image_noising_scheduler,
                # regular denoising components
                """tokenizer""": tokenizer,
                """text_encoder""": text_encoder,
                """unet""": unet,
                """scheduler""": scheduler,
                """vae""": vae,
            }

            return components




      def 				lowercase__    (			self			: int			,			__snake_case			: List[str]			,			__snake_case			: int=0  )				->      Tuple:
            if str(__snake_case  ).startswith("""mps"""  ):
                  _lowerCAmelCase							     =							torch.manual_seed(__snake_case  )
            else:
                  _lowerCAmelCase							     =							torch.Generator(device=__snake_case  ).manual_seed(__snake_case  )
            _lowerCAmelCase							     =							{
                """prompt""": """A painting of a squirrel eating a burger""",
                """generator""": generator,
                """num_inference_steps""": 2,
                """prior_num_inference_steps""": 2,
                """output_type""": """numpy""",
            }
            return inputs




      def 				lowercase__    (			self			: str  )				->      Optional[Any]:
            _lowerCAmelCase							     =							torch_device == """cpu"""

            self._test_attention_slicing_forward_pass(test_max_difference=__snake_case  )




      def 				lowercase__    (			self			: List[str]  )				->      List[str]:
            _lowerCAmelCase							     =							torch_device in ["""cpu""", """mps"""]

            self._test_inference_batch_single_identical(test_max_difference=__snake_case  )




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




      def 				lowercase__    (			self			: Union[str, Any]  )				->      List[Any]:
            super().tearDown()
            gc.collect()
            torch.cuda.empty_cache()




      def 				lowercase__    (			self			: Union[str, Any]  )				->      List[str]:
            _lowerCAmelCase							     =							load_numpy(
                """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/stable_unclip_2_1_l_anime_turtle_fp16.npy"""  )

            _lowerCAmelCase							     =							StableUnCLIPPipeline.from_pretrained("""fusing/stable-unclip-2-1-l"""			,			torch_dtype=torch.floataa  )
            pipe.to(__snake_case  )
            pipe.set_progress_bar_config(disable=__snake_case  )
            # stable unclip will oom when integration tests are run on a V100,
            # so turn on memory savings
            pipe.enable_attention_slicing()
            pipe.enable_sequential_cpu_offload()

            _lowerCAmelCase							     =							torch.Generator(device="""cpu"""  ).manual_seed(0  )
            _lowerCAmelCase							     =							pipe("""anime turle"""			,			generator=__snake_case			,			output_type="""np"""  )

            _lowerCAmelCase							     =							output.images[0]

            assert image.shape == (7_68, 7_68, 3)

            assert_mean_pixel_difference(__snake_case			,			__snake_case  )




      def 				lowercase__    (			self			: Tuple  )				->      Dict:
            torch.cuda.empty_cache()
            torch.cuda.reset_max_memory_allocated()
            torch.cuda.reset_peak_memory_stats()

            _lowerCAmelCase							     =							StableUnCLIPPipeline.from_pretrained("""fusing/stable-unclip-2-1-l"""			,			torch_dtype=torch.floataa  )
            _lowerCAmelCase							     =							pipe.to(__snake_case  )
            pipe.set_progress_bar_config(disable=__snake_case  )
            pipe.enable_attention_slicing()
            pipe.enable_sequential_cpu_offload()

            _lowerCAmelCase							     =							pipe(
                """anime turtle"""			,			prior_num_inference_steps=2			,			num_inference_steps=2			,			output_type="""np"""			,			)

            _lowerCAmelCase							     =							torch.cuda.max_memory_allocated()
            # make sure that less than 7 GB is allocated
            assert mem_bytes < 7 * 10**9










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



