



import json
import os
import re
import unicodedata
from typing import Optional, Tuple

from ...tokenization_utils import PreTrainedTokenizer, _is_control, _is_punctuation, _is_whitespace
from ...utils import logging


a			:     Any     = logging.get_logger(__name__)

a			:     List[str]     = {
    'vocab_file': 'vocab.json',
    'merges_file': 'merges.txt',
}

a			:     Union[str, Any]     = {
    'vocab_file': {'openai-gpt': 'https://huggingface.co/openai-gpt/resolve/main/vocab.json'},
    'merges_file': {'openai-gpt': 'https://huggingface.co/openai-gpt/resolve/main/merges.txt'},
}

a			:     List[str]     = {
    'openai-gpt': 512,
}







def    lowerCAmelCase_  (lowerCAmelCase__:		Any     ):





   """simple docstring"""


   UpperCAmelCase_:		Optional[int]       			=    text.strip()
   if not text:
      return []
   UpperCAmelCase_:		Union[str, Any]       			=    text.split()
   return tokens







class 							_a							(      A__				):

   def __init__(self,      SCREAMING_SNAKE_CASE_=True,      SCREAMING_SNAKE_CASE_=None,      SCREAMING_SNAKE_CASE_=True,      SCREAMING_SNAKE_CASE_=None,      SCREAMING_SNAKE_CASE_=True,      )					->      List[Any]:
      if never_split is None:
         UpperCAmelCase_:		Optional[Any]       			=    []
      UpperCAmelCase_:		Any       			=    do_lower_case
      UpperCAmelCase_:		int       			=    set(_lowerCAmelCase				)
      UpperCAmelCase_:		Union[str, Any]       			=    tokenize_chinese_chars
      UpperCAmelCase_:		Optional[Any]       			=    strip_accents
      UpperCAmelCase_:		List[str]       			=    do_split_on_punc

   def     __snake_case					(self,      SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_=None				)					->      List[str]:
      UpperCAmelCase_:		Optional[Any]       			=    self.never_split.union(set(_lowerCAmelCase				)				) if never_split else self.never_split
      UpperCAmelCase_:		int       			=    self._clean_text(_lowerCAmelCase				)

      # This was added on November 1st, 2018 for the multilingual and Chinese
      # models. This is also applied to the English models now, but it doesn't
      # matter since the English models were not trained on any Chinese data
      # and generally don't have any Chinese data in them (there are Chinese
      # characters in the vocabulary because Wikipedia does have some Chinese
      # words in the English Wikipedia.).
      if self.tokenize_chinese_chars:
         UpperCAmelCase_:		Optional[Any]       			=    self._tokenize_chinese_chars(_lowerCAmelCase				)
      # prevents treating the same character with different unicode codepoints as different characters
      UpperCAmelCase_:		int       			=    unicodedata.normalize("""NFC""",      _lowerCAmelCase				)
      UpperCAmelCase_:		Optional[Any]       			=    whitespace_tokenize(_lowerCAmelCase				)
      UpperCAmelCase_:		Any       			=    []
      for token in orig_tokens:
         if token not in never_split:
            if self.do_lower_case:
               UpperCAmelCase_:		Tuple       			=    token.lower()
               if self.strip_accents is not False:
                  UpperCAmelCase_:		Optional[int]       			=    self._run_strip_accents(_lowerCAmelCase				)
            elif self.strip_accents:
               UpperCAmelCase_:		Any       			=    self._run_strip_accents(_lowerCAmelCase				)
         split_tokens.extend(self._run_split_on_punc(_lowerCAmelCase,      _lowerCAmelCase				)				)

      UpperCAmelCase_:		Dict       			=    whitespace_tokenize(""" """.join(_lowerCAmelCase				)				)
      return output_tokens

   def     __snake_case					(self,      SCREAMING_SNAKE_CASE_				)					->      List[Any]:
      UpperCAmelCase_:		List[str]       			=    unicodedata.normalize("""NFD""",      _lowerCAmelCase				)
      UpperCAmelCase_:		Tuple       			=    []
      for char in text:
         UpperCAmelCase_:		Dict       			=    unicodedata.category(_lowerCAmelCase				)
         if cat == "Mn":
            continue
         output.append(_lowerCAmelCase				)
      return "".join(_lowerCAmelCase				)

   def     __snake_case					(self,      SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_=None				)					->      Dict:
      if not self.do_split_on_punc or (never_split is not None and text in never_split):
         return [text]
      UpperCAmelCase_:		Optional[int]       			=    list(_lowerCAmelCase				)
      UpperCAmelCase_:		List[Any]       			=    0
      UpperCAmelCase_:		Optional[Any]       			=    True
      UpperCAmelCase_:		Any       			=    []
      while i < len(_lowerCAmelCase				):
         UpperCAmelCase_:		int       			=    chars[i]
         if _is_punctuation(_lowerCAmelCase				):
            output.append([char]				)
            UpperCAmelCase_:		str       			=    True
         else:
            if start_new_word:
               output.append([]				)
            UpperCAmelCase_:		Dict       			=    False
            output[-1].append(_lowerCAmelCase				)
         i += 1

      return ["".join(_lowerCAmelCase				) for x in output]

   def     __snake_case					(self,      SCREAMING_SNAKE_CASE_				)					->      str:
      UpperCAmelCase_:		Union[str, Any]       			=    []
      for char in text:
         UpperCAmelCase_:		Dict       			=    ord(_lowerCAmelCase				)
         if self._is_chinese_char(_lowerCAmelCase				):
            output.append(""" """				)
            output.append(_lowerCAmelCase				)
            output.append(""" """				)
         else:
            output.append(_lowerCAmelCase				)
      return "".join(_lowerCAmelCase				)

   def     __snake_case					(self,      SCREAMING_SNAKE_CASE_				)					->      Dict:
      # This defines a "chinese character" as anything in the CJK Unicode block:
      #   https://en.wikipedia.org/wiki/CJK_Unified_Ideographs_(Unicode_block)
      #
      # Note that the CJK Unicode block is NOT all Japanese and Korean characters,
      # despite its name. The modern Korean Hangul alphabet is a different block,
      # as is Japanese Hiragana and Katakana. Those alphabets are used to write
      # space-separated words, so they are not treated specially and handled
      # like the all of the other languages.
      if (
          (cp >= 0X4e_00 and cp <= 0X9f_ff)
          or (cp >= 0X34_00 and cp <= 0X4d_bf)  #
          or (cp >= 0X2_00_00 and cp <= 0X2_a6_df)  #
          or (cp >= 0X2_a7_00 and cp <= 0X2_b7_3f)  #
          or (cp >= 0X2_b7_40 and cp <= 0X2_b8_1f)  #
          or (cp >= 0X2_b8_20 and cp <= 0X2_ce_af)  #
          or (cp >= 0Xf9_00 and cp <= 0Xfa_ff)
          or (cp >= 0X2_f8_00 and cp <= 0X2_fa_1f)  #
      ):  #
         return True

      return False

   def     __snake_case					(self,      SCREAMING_SNAKE_CASE_				)					->      str:
      UpperCAmelCase_:		Optional[int]       			=    []
      for char in text:
         UpperCAmelCase_:		Any       			=    ord(_lowerCAmelCase				)
         if cp == 0 or cp == 0Xff_fd or _is_control(_lowerCAmelCase				):
            continue
         if _is_whitespace(_lowerCAmelCase				):
            output.append(""" """				)
         else:
            output.append(_lowerCAmelCase				)
      return "".join(_lowerCAmelCase				)







def    lowerCAmelCase_  (lowerCAmelCase__:		Union[str, Any]     ):





   """simple docstring"""


   UpperCAmelCase_:		int       			=    set()
   UpperCAmelCase_:		str       			=    word[0]
   for char in word[1:]:
      pairs.add((prev_char, char)     )
      UpperCAmelCase_:		Tuple       			=    char
   return pairs







def    lowerCAmelCase_  (lowerCAmelCase__:		Optional[int]     ):





   """simple docstring"""


   UpperCAmelCase_:		int       			=    text.replace("""—"""		,	"""-"""     )
   UpperCAmelCase_:		Optional[Any]       			=    text.replace("""–"""		,	"""-"""     )
   UpperCAmelCase_:		List[Any]       			=    text.replace("""―"""		,	"""-"""     )
   UpperCAmelCase_:		List[Any]       			=    text.replace("""…"""		,	"""..."""     )
   UpperCAmelCase_:		Union[str, Any]       			=    text.replace("""´"""		,	"""'"""     )
   UpperCAmelCase_:		List[str]       			=    re.sub(r"""(-+|~+|!+|\"+|;+|\?+|\++|,+|\)+|\(+|\\+|\/+|\*+|\[+|\]+|}+|{+|\|+|_+)"""		,	r""" \1 """		,	lowerCAmelCase__     )
   UpperCAmelCase_:		Optional[Any]       			=    re.sub(r"""\s*\n\s*"""		,	""" \n """		,	lowerCAmelCase__     )
   UpperCAmelCase_:		Optional[int]       			=    re.sub(r"""[^\S\n]+"""		,	""" """		,	lowerCAmelCase__     )
   return text.strip()







class 							_a							(      A__				):
   A					=  VOCAB_FILES_NAMES
   A					=  PRETRAINED_VOCAB_FILES_MAP
   A					=  PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
   A					=  ['''input_ids''', '''attention_mask''']

   def __init__(self,      SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_="<unk>",      **SCREAMING_SNAKE_CASE_				)					->      List[Any]:
      super().__init__(unk_token=_lowerCAmelCase,      **_lowerCAmelCase				)

      try:
         import ftfy
         from spacy.lang.en import English

         UpperCAmelCase_:		Optional[int]       			=    English()
         UpperCAmelCase_:		Dict       			=    _nlp.tokenizer
         UpperCAmelCase_:		Optional[Any]       			=    ftfy.fix_text
      except ImportError:
         logger.warning("""ftfy or spacy is not installed using BERT BasicTokenizer instead of SpaCy & ftfy."""				)
         UpperCAmelCase_:		str       			=    BasicTokenizer(do_lower_case=_lowerCAmelCase				)
         UpperCAmelCase_:		List[str]       			=    None

      with open(_lowerCAmelCase,      encoding="""utf-8"""				) as vocab_handle:
         UpperCAmelCase_:		Dict       			=    json.load(_lowerCAmelCase				)
      UpperCAmelCase_:		int       			=    {v: k for k, v in self.encoder.items()}
      with open(_lowerCAmelCase,      encoding="""utf-8"""				) as merges_handle:
         UpperCAmelCase_:		Optional[Any]       			=    merges_handle.read().split("""\n"""				)[1:-1]
      UpperCAmelCase_:		Any       			=    [tuple(merge.split()				) for merge in merges]
      UpperCAmelCase_:		int       			=    dict(zip(_lowerCAmelCase,      range(len(_lowerCAmelCase				)				)				)				)
      UpperCAmelCase_:		List[Any]       			=    {}

   @property
   def     __snake_case					(self				)					->      List[Any]:
      return True

   @property
   def     __snake_case					(self				)					->      List[Any]:
      return len(self.encoder				)

   def     __snake_case					(self				)					->      List[Any]:
      return dict(self.encoder,      **self.added_tokens_encoder				)

   def     __snake_case					(self,      SCREAMING_SNAKE_CASE_				)					->      Any:
      UpperCAmelCase_:		str       			=    tuple(token[:-1]				) + (token[-1] + """</w>""",)
      if token in self.cache:
         return self.cache[token]
      UpperCAmelCase_:		Any       			=    get_pairs(_lowerCAmelCase				)

      if not pairs:
         return token + "</w>"

      while True:
         UpperCAmelCase_:		List[str]       			=    min(_lowerCAmelCase,      key=lambda SCREAMING_SNAKE_CASE_				: self.bpe_ranks.get(_lowerCAmelCase,      float("""inf"""				)				)				)
         if bigram not in self.bpe_ranks:
            break
         UpperCAmelCase_			,       UpperCAmelCase_:		Dict       			=    bigram
         UpperCAmelCase_:		Union[str, Any]       			=    []
         UpperCAmelCase_:		Optional[Any]       			=    0
         while i < len(_lowerCAmelCase				):
            try:
               UpperCAmelCase_:		List[Any]       			=    word.index(_lowerCAmelCase,      _lowerCAmelCase				)
            except ValueError:
               new_word.extend(word[i:]				)
               break
            else:
               new_word.extend(word[i:j]				)
               UpperCAmelCase_:		List[Any]       			=    j

            if word[i] == first and i < len(_lowerCAmelCase				) - 1 and word[i + 1] == second:
               new_word.append(first + second				)
               i += 2
            else:
               new_word.append(word[i]				)
               i += 1
         UpperCAmelCase_:		int       			=    tuple(_lowerCAmelCase				)
         UpperCAmelCase_:		Union[str, Any]       			=    new_word
         if len(_lowerCAmelCase				) == 1:
            break
         else:
            UpperCAmelCase_:		Any       			=    get_pairs(_lowerCAmelCase				)
      UpperCAmelCase_:		List[Any]       			=    """ """.join(_lowerCAmelCase				)
      if word == "\n  </w>":
         UpperCAmelCase_:		Dict       			=    """\n</w>"""
      UpperCAmelCase_:		str       			=    word
      return word

   def     __snake_case					(self,      SCREAMING_SNAKE_CASE_				)					->      Dict:
      UpperCAmelCase_:		str       			=    []
      if self.fix_text is None:
         # Using BERT's BasicTokenizer
         UpperCAmelCase_:		Dict       			=    self.nlp.tokenize(_lowerCAmelCase				)
         for token in text:
            split_tokens.extend(list(self.bpe(_lowerCAmelCase				).split(""" """				)				)				)
      else:
         # Using SpaCy & ftfy (original tokenization process of OpenAI GPT)
         UpperCAmelCase_:		List[str]       			=    self.nlp(text_standardize(self.fix_text(_lowerCAmelCase				)				)				)
         for token in text:
            split_tokens.extend(list(self.bpe(token.text.lower()				).split(""" """				)				)				)
      return split_tokens

   def     __snake_case					(self,      SCREAMING_SNAKE_CASE_				)					->      Optional[int]:
      return self.encoder.get(_lowerCAmelCase,      self.encoder.get(self.unk_token				)				)

   def     __snake_case					(self,      SCREAMING_SNAKE_CASE_				)					->      Any:
      return self.decoder.get(_lowerCAmelCase,      self.unk_token				)

   def     __snake_case					(self,      SCREAMING_SNAKE_CASE_				)					->      Dict:
      UpperCAmelCase_:		Any       			=    """""".join(_lowerCAmelCase				).replace("""</w>""",      """ """				).strip()
      return out_string

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

      with open(_lowerCAmelCase,      """w""",      encoding="""utf-8"""				) as f:
         f.write(json.dumps(self.encoder,      indent=2,      sort_keys=_lowerCAmelCase,      ensure_ascii=_lowerCAmelCase				) + """\n"""				)

      UpperCAmelCase_:		List[str]       			=    0
      with open(_lowerCAmelCase,      """w""",      encoding="""utf-8"""				) as writer:
         writer.write("""#version: 0.2\n"""				)
         for bpe_tokens, token_index in sorted(self.bpe_ranks.items(),      key=lambda SCREAMING_SNAKE_CASE_				: kv[1]				):
            if index != token_index:
               logger.warning(
                   f'Saving vocabulary to {merge_file}: BPE merge indices are not consecutive.'
                   """ Please check that the tokenizer is not corrupted!"""				)
               UpperCAmelCase_:		Dict       			=    token_index
            writer.write(""" """.join(_lowerCAmelCase				) + """\n"""				)
            index += 1

      return vocab_file, merge_file











import gc
import random
import tempfile
import unittest

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

from diffusers import AutoencoderKL, DDIMScheduler, LMSDiscreteScheduler, PNDMScheduler, UNetaDConditionModel
from diffusers.pipelines.semantic_stable_diffusion import SemanticStableDiffusionPipeline as StableDiffusionPipeline
from diffusers.utils import floats_tensor, nightly, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu


enable_full_determinism()







class 							_a							(      unittest.TestCase				):

			def     __snake_case					(self				)					->      Any:
						# clean up the VRAM after each test
						super().tearDown()
						gc.collect()
						torch.cuda.empty_cache()

			@property
			def     __snake_case					(self				)					->      Tuple:
						UpperCAmelCase_:		Tuple       			=    1
						UpperCAmelCase_:		Dict       			=    3
						UpperCAmelCase_:		Optional[int]       			=    (32, 32)

						UpperCAmelCase_:		int       			=    floats_tensor((batch_size, num_channels) + sizes,      rng=random.Random(0				)				).to(SCREAMING_SNAKE_CASE_				)
						return image

			@property
			def     __snake_case					(self				)					->      Optional[Any]:
						torch.manual_seed(0				)
						UpperCAmelCase_:		Tuple       			=    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,      )
						return model

			@property
			def     __snake_case					(self				)					->      str:
						torch.manual_seed(0				)
						UpperCAmelCase_:		int       			=    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,      )
						return model

			@property
			def     __snake_case					(self				)					->      List[str]:
						torch.manual_seed(0				)
						UpperCAmelCase_:		Tuple       			=    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,      )
						return CLIPTextModel(SCREAMING_SNAKE_CASE_				)

			@property
			def     __snake_case					(self				)					->      str:
						def extract(*SCREAMING_SNAKE_CASE_,      **SCREAMING_SNAKE_CASE_				):







									class 							_a							:

												def __init__(self				)					->      Any:
															UpperCAmelCase_:		Optional[Any]       			=    torch.ones([0]				)

												def     __snake_case					(self,      SCREAMING_SNAKE_CASE_				)					->      int:
															self.pixel_values.to(SCREAMING_SNAKE_CASE_				)
															return self






									return Out()

						return extract

			def     __snake_case					(self				)					->      List[Any]:
						UpperCAmelCase_:		Any       			=    """cpu"""  # ensure determinism for the device-dependent torch.Generator
						UpperCAmelCase_:		Dict       			=    self.dummy_cond_unet
						UpperCAmelCase_:		Union[str, Any]       			=    DDIMScheduler(
						    beta_start=0.0_0_0_8_5,      beta_end=0.0_1_2,      beta_schedule="""scaled_linear""",      clip_sample=SCREAMING_SNAKE_CASE_,      set_alpha_to_one=SCREAMING_SNAKE_CASE_,      )

						UpperCAmelCase_:		List[str]       			=    self.dummy_vae
						UpperCAmelCase_:		Union[str, Any]       			=    self.dummy_text_encoder
						UpperCAmelCase_:		Dict       			=    CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""				)

						# make sure here that pndm scheduler skips prk
						UpperCAmelCase_:		str       			=    StableDiffusionPipeline(
						    unet=SCREAMING_SNAKE_CASE_,      scheduler=SCREAMING_SNAKE_CASE_,      vae=SCREAMING_SNAKE_CASE_,      text_encoder=SCREAMING_SNAKE_CASE_,      tokenizer=SCREAMING_SNAKE_CASE_,      safety_checker=SCREAMING_SNAKE_CASE_,      feature_extractor=self.dummy_extractor,      )
						UpperCAmelCase_:		str       			=    sd_pipe.to(SCREAMING_SNAKE_CASE_				)
						sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_				)

						UpperCAmelCase_:		int       			=    """A painting of a squirrel eating a burger"""

						UpperCAmelCase_:		Tuple       			=    torch.Generator(device=SCREAMING_SNAKE_CASE_				).manual_seed(0				)
						UpperCAmelCase_:		Dict       			=    sd_pipe([prompt],      generator=SCREAMING_SNAKE_CASE_,      guidance_scale=6.0,      num_inference_steps=2,      output_type="""np"""				)
						UpperCAmelCase_:		Tuple       			=    output.images

						UpperCAmelCase_:		List[Any]       			=    torch.Generator(device=SCREAMING_SNAKE_CASE_				).manual_seed(0				)
						UpperCAmelCase_:		List[str]       			=    sd_pipe(
						    [prompt],      generator=SCREAMING_SNAKE_CASE_,      guidance_scale=6.0,      num_inference_steps=2,      output_type="""np""",      return_dict=SCREAMING_SNAKE_CASE_,      )[0]

						UpperCAmelCase_:		int       			=    image[0, -3:, -3:, -1]
						UpperCAmelCase_:		List[str]       			=    image_from_tuple[0, -3:, -3:, -1]

						assert image.shape == (1, 64, 64, 3)
						UpperCAmelCase_:		Dict       			=    np.array([0.5_7_5_3, 0.6_1_1_4, 0.5_0_0_1, 0.5_0_3_4, 0.5_4_7_0, 0.4_7_2_9, 0.4_9_7_1, 0.4_8_6_7, 0.4_8_6_7]				)

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

			def     __snake_case					(self				)					->      Any:
						UpperCAmelCase_:		List[Any]       			=    """cpu"""  # ensure determinism for the device-dependent torch.Generator
						UpperCAmelCase_:		Tuple       			=    self.dummy_cond_unet
						UpperCAmelCase_:		Optional[int]       			=    PNDMScheduler(skip_prk_steps=SCREAMING_SNAKE_CASE_				)
						UpperCAmelCase_:		Union[str, Any]       			=    self.dummy_vae
						UpperCAmelCase_:		Any       			=    self.dummy_text_encoder
						UpperCAmelCase_:		List[Any]       			=    CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""				)

						# make sure here that pndm scheduler skips prk
						UpperCAmelCase_:		List[str]       			=    StableDiffusionPipeline(
						    unet=SCREAMING_SNAKE_CASE_,      scheduler=SCREAMING_SNAKE_CASE_,      vae=SCREAMING_SNAKE_CASE_,      text_encoder=SCREAMING_SNAKE_CASE_,      tokenizer=SCREAMING_SNAKE_CASE_,      safety_checker=SCREAMING_SNAKE_CASE_,      feature_extractor=self.dummy_extractor,      )
						UpperCAmelCase_:		List[str]       			=    sd_pipe.to(SCREAMING_SNAKE_CASE_				)
						sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_				)

						UpperCAmelCase_:		int       			=    """A painting of a squirrel eating a burger"""
						UpperCAmelCase_:		Union[str, Any]       			=    torch.Generator(device=SCREAMING_SNAKE_CASE_				).manual_seed(0				)
						UpperCAmelCase_:		List[Any]       			=    sd_pipe([prompt],      generator=SCREAMING_SNAKE_CASE_,      guidance_scale=6.0,      num_inference_steps=2,      output_type="""np"""				)

						UpperCAmelCase_:		Optional[int]       			=    output.images

						UpperCAmelCase_:		Any       			=    torch.Generator(device=SCREAMING_SNAKE_CASE_				).manual_seed(0				)
						UpperCAmelCase_:		Tuple       			=    sd_pipe(
						    [prompt],      generator=SCREAMING_SNAKE_CASE_,      guidance_scale=6.0,      num_inference_steps=2,      output_type="""np""",      return_dict=SCREAMING_SNAKE_CASE_,      )[0]

						UpperCAmelCase_:		Optional[Any]       			=    image[0, -3:, -3:, -1]
						UpperCAmelCase_:		Tuple       			=    image_from_tuple[0, -3:, -3:, -1]

						assert image.shape == (1, 64, 64, 3)
						UpperCAmelCase_:		Tuple       			=    np.array([0.5_1_2_2, 0.5_7_1_2, 0.4_8_2_5, 0.5_0_5_3, 0.5_6_4_6, 0.4_7_6_9, 0.5_1_7_9, 0.4_8_9_4, 0.4_9_9_4]				)

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

			def     __snake_case					(self				)					->      List[str]:
						UpperCAmelCase_:		Dict       			=    StableDiffusionPipeline.from_pretrained(
						    """hf-internal-testing/tiny-stable-diffusion-lms-pipe""",      safety_checker=SCREAMING_SNAKE_CASE_				)
						assert isinstance(SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_				)
						assert isinstance(pipe.scheduler,      SCREAMING_SNAKE_CASE_				)
						assert pipe.safety_checker is None

						UpperCAmelCase_:		Optional[Any]       			=    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(SCREAMING_SNAKE_CASE_				)
									UpperCAmelCase_:		Optional[int]       			=    StableDiffusionPipeline.from_pretrained(SCREAMING_SNAKE_CASE_				)

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

			@unittest.skipIf(torch_device != """cuda""",      """This test requires a GPU"""				)
			def     __snake_case					(self				)					->      Optional[Any]:
						UpperCAmelCase_:		Dict       			=    self.dummy_cond_unet
						UpperCAmelCase_:		Any       			=    PNDMScheduler(skip_prk_steps=SCREAMING_SNAKE_CASE_				)
						UpperCAmelCase_:		List[str]       			=    self.dummy_vae
						UpperCAmelCase_:		Tuple       			=    self.dummy_text_encoder
						UpperCAmelCase_:		Dict       			=    CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""				)

						# put models in fp16
						UpperCAmelCase_:		Dict       			=    unet.half()
						UpperCAmelCase_:		Optional[Any]       			=    vae.half()
						UpperCAmelCase_:		Union[str, Any]       			=    bert.half()

						# make sure here that pndm scheduler skips prk
						UpperCAmelCase_:		str       			=    StableDiffusionPipeline(
						    unet=SCREAMING_SNAKE_CASE_,      scheduler=SCREAMING_SNAKE_CASE_,      vae=SCREAMING_SNAKE_CASE_,      text_encoder=SCREAMING_SNAKE_CASE_,      tokenizer=SCREAMING_SNAKE_CASE_,      safety_checker=SCREAMING_SNAKE_CASE_,      feature_extractor=self.dummy_extractor,      )
						UpperCAmelCase_:		Optional[Any]       			=    sd_pipe.to(SCREAMING_SNAKE_CASE_				)
						sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_				)

						UpperCAmelCase_:		str       			=    """A painting of a squirrel eating a burger"""
						UpperCAmelCase_:		Optional[Any]       			=    sd_pipe([prompt],      num_inference_steps=2,      output_type="""np"""				).images

						assert image.shape == (1, 64, 64, 3)







@nightly
@require_torch_gpu
class 							_a							(      unittest.TestCase				):

			def     __snake_case					(self				)					->      Dict:
						# clean up the VRAM after each test
						super().tearDown()
						gc.collect()
						torch.cuda.empty_cache()

			def     __snake_case					(self				)					->      str:
						UpperCAmelCase_:		Optional[int]       			=    """cuda"""
						UpperCAmelCase_:		List[str]       			=    StableDiffusionPipeline.from_pretrained("""runwayml/stable-diffusion-v1-5"""				)
						UpperCAmelCase_:		Union[str, Any]       			=    pipe.to(SCREAMING_SNAKE_CASE_				)
						pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_				)

						UpperCAmelCase_:		int       			=    """a photo of a cat"""
						UpperCAmelCase_:		Tuple       			=    {
						    """editing_prompt""": ["""sunglasses"""],
						    """reverse_editing_direction""": [False],
						    """edit_warmup_steps""": 10,
						    """edit_guidance_scale""": 6,
						    """edit_threshold""": 0.9_5,
						    """edit_momentum_scale""": 0.5,
						    """edit_mom_beta""": 0.6,
						}

						UpperCAmelCase_:		List[str]       			=    3
						UpperCAmelCase_:		str       			=    7

						# no sega enabled
						UpperCAmelCase_:		Tuple       			=    torch.Generator(SCREAMING_SNAKE_CASE_				)
						generator.manual_seed(SCREAMING_SNAKE_CASE_				)
						UpperCAmelCase_:		Any       			=    pipe(
						    [prompt],      generator=SCREAMING_SNAKE_CASE_,      guidance_scale=SCREAMING_SNAKE_CASE_,      num_inference_steps=50,      output_type="""np""",      width=512,      height=512,      )

						UpperCAmelCase_:		Optional[Any]       			=    output.images
						UpperCAmelCase_:		List[Any]       			=    image[0, -3:, -3:, -1]
						UpperCAmelCase_:		Optional[int]       			=    [
						    0.3_4_6_7_3_1_1_3,
						    0.3_8_4_9_2_7_3_3,
						    0.3_7_5_9_7_3_5_2,
						    0.3_4_0_8_6_3_3_5,
						    0.3_5_6_5_0_7_4_8,
						    0.3_5_5_7_9_2_0_5,
						    0.3_3_8_4_7_6_3,
						    0.3_4_3_4_0_2_3_6,
						    0.3_5_7_3_2_7_1,
						]

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

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

						# with sega enabled
						# generator = torch.manual_seed(seed)
						generator.manual_seed(SCREAMING_SNAKE_CASE_				)
						UpperCAmelCase_:		Optional[Any]       			=    pipe(
						    [prompt],      generator=SCREAMING_SNAKE_CASE_,      guidance_scale=SCREAMING_SNAKE_CASE_,      num_inference_steps=50,      output_type="""np""",      width=512,      height=512,      **SCREAMING_SNAKE_CASE_,      )

						UpperCAmelCase_:		Any       			=    output.images
						UpperCAmelCase_:		Dict       			=    image[0, -3:, -3:, -1]
						UpperCAmelCase_:		Optional[int]       			=    [
						    0.4_1_8_8_7_8_2_6,
						    0.3_7_7_2_8_7_6_6,
						    0.3_0_1_3_8_2_7_2,
						    0.4_1_4_1_6_3_3_5,
						    0.4_1_6_6_4_9_8_5,
						    0.3_6_2_8_3_3_9_2,
						    0.3_6_1_9_1_2_4_6,
						    0.4_3_3_6_4_4_6_5,
						    0.4_3_0_0_1_7_3_2,
						]

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

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

			def     __snake_case					(self				)					->      Optional[Any]:
						UpperCAmelCase_:		List[Any]       			=    """cuda"""
						UpperCAmelCase_:		Tuple       			=    StableDiffusionPipeline.from_pretrained("""runwayml/stable-diffusion-v1-5"""				)
						UpperCAmelCase_:		List[Any]       			=    pipe.to(SCREAMING_SNAKE_CASE_				)
						pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_				)

						UpperCAmelCase_:		Dict       			=    """an image of a crowded boulevard, realistic, 4k"""
						UpperCAmelCase_:		Optional[Any]       			=    {
						    """editing_prompt""": """crowd, crowded, people""",
						    """reverse_editing_direction""": True,
						    """edit_warmup_steps""": 10,
						    """edit_guidance_scale""": 8.3,
						    """edit_threshold""": 0.9,
						    """edit_momentum_scale""": 0.5,
						    """edit_mom_beta""": 0.6,
						}

						UpperCAmelCase_:		Dict       			=    9
						UpperCAmelCase_:		Optional[int]       			=    7

						# no sega enabled
						UpperCAmelCase_:		List[Any]       			=    torch.Generator(SCREAMING_SNAKE_CASE_				)
						generator.manual_seed(SCREAMING_SNAKE_CASE_				)
						UpperCAmelCase_:		str       			=    pipe(
						    [prompt],      generator=SCREAMING_SNAKE_CASE_,      guidance_scale=SCREAMING_SNAKE_CASE_,      num_inference_steps=50,      output_type="""np""",      width=512,      height=512,      )

						UpperCAmelCase_:		Optional[Any]       			=    output.images
						UpperCAmelCase_:		List[Any]       			=    image[0, -3:, -3:, -1]
						UpperCAmelCase_:		int       			=    [
						    0.4_3_4_9_7_9_9_8,
						    0.9_1_8_1_4_0_6_5,
						    0.7_5_4_0_7_3_9,
						    0.5_5_5_8_0_2_0_5,
						    0.8_4_6_7_2_6_5,
						    0.5_3_8_9_6_9_1,
						    0.6_2_5_7_4_5_0_6,
						    0.5_8_8_9_7_7_6_3,
						    0.5_0_9_2_6_7_5_7,
						]

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

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

						# with sega enabled
						# generator = torch.manual_seed(seed)
						generator.manual_seed(SCREAMING_SNAKE_CASE_				)
						UpperCAmelCase_:		Optional[int]       			=    pipe(
						    [prompt],      generator=SCREAMING_SNAKE_CASE_,      guidance_scale=SCREAMING_SNAKE_CASE_,      num_inference_steps=50,      output_type="""np""",      width=512,      height=512,      **SCREAMING_SNAKE_CASE_,      )

						UpperCAmelCase_:		int       			=    output.images
						UpperCAmelCase_:		Any       			=    image[0, -3:, -3:, -1]
						UpperCAmelCase_:		str       			=    [
						    0.3_0_8_9_7_1_9,
						    0.3_0_5_0_0_1_4_4,
						    0.2_9_0_1_6_0_4_2,
						    0.3_0_6_3_0_9_6_4,
						    0.3_2_5_6_8_7,
						    0.2_9_4_1_9_2_2_5,
						    0.2_9_0_8_0_9_1,
						    0.2_8_7_2_3_5_9_8,
						    0.2_7_6_9_6_2_9_4,
						]

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

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

			def     __snake_case					(self				)					->      Tuple:
						UpperCAmelCase_:		Union[str, Any]       			=    """cuda"""
						UpperCAmelCase_:		Optional[Any]       			=    StableDiffusionPipeline.from_pretrained("""runwayml/stable-diffusion-v1-5"""				)
						UpperCAmelCase_:		Optional[Any]       			=    pipe.to(SCREAMING_SNAKE_CASE_				)
						pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_				)

						UpperCAmelCase_:		Tuple       			=    """a castle next to a river"""
						UpperCAmelCase_:		Optional[Any]       			=    {
						    """editing_prompt""": ["""boat on a river, boat""", """monet, impression, sunrise"""],
						    """reverse_editing_direction""": False,
						    """edit_warmup_steps""": [15, 18],
						    """edit_guidance_scale""": 6,
						    """edit_threshold""": [0.9, 0.8],
						    """edit_momentum_scale""": 0.5,
						    """edit_mom_beta""": 0.6,
						}

						UpperCAmelCase_:		str       			=    48
						UpperCAmelCase_:		Optional[int]       			=    7

						# no sega enabled
						UpperCAmelCase_:		int       			=    torch.Generator(SCREAMING_SNAKE_CASE_				)
						generator.manual_seed(SCREAMING_SNAKE_CASE_				)
						UpperCAmelCase_:		Union[str, Any]       			=    pipe(
						    [prompt],      generator=SCREAMING_SNAKE_CASE_,      guidance_scale=SCREAMING_SNAKE_CASE_,      num_inference_steps=50,      output_type="""np""",      width=512,      height=512,      )

						UpperCAmelCase_:		Tuple       			=    output.images
						UpperCAmelCase_:		Tuple       			=    image[0, -3:, -3:, -1]
						UpperCAmelCase_:		Tuple       			=    [
						    0.7_5_1_6_3_5_5_5,
						    0.7_6_0_3_7_1_4_5,
						    0.6_1_7_8_5,
						    0.9_1_8_9_6_7_3,
						    0.8_6_2_7_7_0_1,
						    0.8_5_1_8_9_6_9_4,
						    0.8_5_1_2_8_1_3,
						    0.8_7_0_1_2_0_7_6,
						    0.8_3_1_2_8_5_7,
						]

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

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

						# with sega enabled
						# generator = torch.manual_seed(seed)
						generator.manual_seed(SCREAMING_SNAKE_CASE_				)
						UpperCAmelCase_:		Dict       			=    pipe(
						    [prompt],      generator=SCREAMING_SNAKE_CASE_,      guidance_scale=SCREAMING_SNAKE_CASE_,      num_inference_steps=50,      output_type="""np""",      width=512,      height=512,      **SCREAMING_SNAKE_CASE_,      )

						UpperCAmelCase_:		List[str]       			=    output.images
						UpperCAmelCase_:		Optional[int]       			=    image[0, -3:, -3:, -1]
						UpperCAmelCase_:		Optional[Any]       			=    [
						    0.7_3_5_5_3_3_6_5,
						    0.7_5_3_7_2_7_1,
						    0.7_4_3_4_1_9_0_5,
						    0.6_6_4_8_0_3_5_6,
						    0.6_4_7_2_9_2_5,
						    0.6_3_0_3_9_4_1_6,
						    0.6_4_8_1_2_9_0_5,
						    0.6_7_4_9_7_1_7,
						    0.6_5_1_7_1_0_2,
						]

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

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

			def     __snake_case					(self				)					->      Optional[int]:
						UpperCAmelCase_:		List[Any]       			=    """cuda"""
						UpperCAmelCase_:		Union[str, Any]       			=    StableDiffusionPipeline.from_pretrained("""runwayml/stable-diffusion-v1-5""",      torch_dtype=torch.floataa				)
						UpperCAmelCase_:		Optional[int]       			=    pipe.to(SCREAMING_SNAKE_CASE_				)
						pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_				)

						UpperCAmelCase_:		Dict       			=    """a photo of a cat"""
						UpperCAmelCase_:		Dict       			=    {
						    """editing_prompt""": ["""sunglasses"""],
						    """reverse_editing_direction""": [False],
						    """edit_warmup_steps""": 10,
						    """edit_guidance_scale""": 6,
						    """edit_threshold""": 0.9_5,
						    """edit_momentum_scale""": 0.5,
						    """edit_mom_beta""": 0.6,
						}

						UpperCAmelCase_:		List[Any]       			=    3
						UpperCAmelCase_:		Dict       			=    7

						# no sega enabled
						UpperCAmelCase_:		Tuple       			=    torch.Generator(SCREAMING_SNAKE_CASE_				)
						generator.manual_seed(SCREAMING_SNAKE_CASE_				)
						UpperCAmelCase_:		List[Any]       			=    pipe(
						    [prompt],      generator=SCREAMING_SNAKE_CASE_,      guidance_scale=SCREAMING_SNAKE_CASE_,      num_inference_steps=50,      output_type="""np""",      width=512,      height=512,      )

						UpperCAmelCase_:		str       			=    output.images
						UpperCAmelCase_:		Optional[Any]       			=    image[0, -3:, -3:, -1]
						UpperCAmelCase_:		List[Any]       			=    [
						    0.3_4_8_8_7_6_9_5,
						    0.3_8_7_6_9_5_3,
						    0.3_7_5,
						    0.3_4_4_2_3_8_2_8,
						    0.3_5_8_1_5_4_3,
						    0.3_5_7_1_7_7_7_3,
						    0.3_3_8_3_7_8_9,
						    0.3_4_5_7_0_3_1_2,
						    0.3_5_9_3_7_5,
						]

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

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

						# with sega enabled
						# generator = torch.manual_seed(seed)
						generator.manual_seed(SCREAMING_SNAKE_CASE_				)
						UpperCAmelCase_:		Any       			=    pipe(
						    [prompt],      generator=SCREAMING_SNAKE_CASE_,      guidance_scale=SCREAMING_SNAKE_CASE_,      num_inference_steps=50,      output_type="""np""",      width=512,      height=512,      **SCREAMING_SNAKE_CASE_,      )

						UpperCAmelCase_:		List[Any]       			=    output.images
						UpperCAmelCase_:		List[str]       			=    image[0, -3:, -3:, -1]
						UpperCAmelCase_:		List[Any]       			=    [
						    0.4_2_2_8_5_1_5_6,
						    0.3_6_9_1_4_0_6_2,
						    0.2_9_0_7_7_1_4_8,
						    0.4_2_0_4_1_0_1_6,
						    0.4_1_9_1_8_9_4_5,
						    0.3_5_4_9_8_0_4_7,
						    0.3_6_1_8_1_6_4,
						    0.4_4_2_3_8_2_8,
						    0.4_3_1_1_5_2_3_4,
						]

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

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






