

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.stable_diffusion_safe import StableDiffusionPipelineSafe as StableDiffusionPipeline
from diffusers.utils import floats_tensor, nightly, torch_device
from diffusers.utils.testing_utils import require_torch_gpu






class 						__magic_name__    (       unittest.TestCase    ):


 def _UpperCamelCase	(						self		: List[Any]    )    ->      Optional[int]:
   # clean up the VRAM after each test
   super().tearDown()
   gc.collect()
   torch.cuda.empty_cache()


 @property
 def _UpperCamelCase	(						self		: Tuple    )    ->      List[str]:
   UpperCAmelCase					      =  1
   UpperCAmelCase					      =  3
   UpperCAmelCase					      =  (3_2, 3_2)

   UpperCAmelCase					      =  floats_tensor((batch_size, num_channels) + sizes			,						rng=random.Random(0    )    ).to(lowerCAmelCase__    )
   return image


 @property
 def _UpperCamelCase	(						self		: List[str]    )    ->      Any:
   torch.manual_seed(0    )
   UpperCAmelCase					      =  UNetaDConditionModel(
       block_out_channels=(3_2, 6_4)			,						layers_per_block=2			,						sample_size=3_2			,						in_channels=4			,						out_channels=4			,						down_block_types=("DownBlock2D", "CrossAttnDownBlock2D")			,						up_block_types=("CrossAttnUpBlock2D", "UpBlock2D")			,						cross_attention_dim=3_2			,						)
   return model


 @property
 def _UpperCamelCase	(						self		: Union[str, Any]    )    ->      Tuple:
   torch.manual_seed(0    )
   UpperCAmelCase					      =  AutoencoderKL(
       block_out_channels=[3_2, 6_4]			,						in_channels=3			,						out_channels=3			,						down_block_types=["DownEncoderBlock2D", "DownEncoderBlock2D"]			,						up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D"]			,						latent_channels=4			,						)
   return model


 @property
 def _UpperCamelCase	(						self		: Dict    )    ->      List[Any]:
   torch.manual_seed(0    )
   UpperCAmelCase					      =  CLIPTextConfig(
       bos_token_id=0			,						eos_token_id=2			,						hidden_size=3_2			,						intermediate_size=3_7			,						layer_norm_eps=1e-0_5			,						num_attention_heads=4			,						num_hidden_layers=5			,						pad_token_id=1			,						vocab_size=1_0_0_0			,						)
   return CLIPTextModel(lowerCAmelCase__    )


 @property
 def _UpperCamelCase	(						self		: Optional[Any]    )    ->      Optional[int]:
   def extract(*lowerCAmelCase__		: Any			,						**lowerCAmelCase__		: List[Any]    ):






     class 						__magic_name__    :


      def __init__(						self		: List[Any]    )    ->      List[str]:
        UpperCAmelCase					      =  torch.ones([0]    )


      def _UpperCamelCase	(						self		: Union[str, Any]			,						lowerCAmelCase__		: Optional[int]    )    ->      str:
        self.pixel_values.to(lowerCAmelCase__    )
        return self

     return Out()

   return extract


 def _UpperCamelCase	(						self		: Any    )    ->      Union[str, Any]:
   UpperCAmelCase					      =  "cpu"  # ensure determinism for the device-dependent torch.Generator
   UpperCAmelCase					      =  self.dummy_cond_unet
   UpperCAmelCase					      =  DDIMScheduler(
       beta_start=0.00_085			,						beta_end=0.012			,						beta_schedule="scaled_linear"			,						clip_sample=lowerCAmelCase__			,						set_alpha_to_one=lowerCAmelCase__			,						)

   UpperCAmelCase					      =  self.dummy_vae
   UpperCAmelCase					      =  self.dummy_text_encoder
   UpperCAmelCase					      =  CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"    )

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

   UpperCAmelCase					      =  "A painting of a squirrel eating a burger"

   UpperCAmelCase					      =  torch.Generator(device=lowerCAmelCase__    ).manual_seed(0    )
   UpperCAmelCase					      =  sd_pipe([prompt]			,						generator=lowerCAmelCase__			,						guidance_scale=6.0			,						num_inference_steps=2			,						output_type="np"    )
   UpperCAmelCase					      =  output.images

   UpperCAmelCase					      =  torch.Generator(device=lowerCAmelCase__    ).manual_seed(0    )
   UpperCAmelCase					      =  sd_pipe(
       [prompt]			,						generator=lowerCAmelCase__			,						guidance_scale=6.0			,						num_inference_steps=2			,						output_type="np"			,						return_dict=lowerCAmelCase__			,						)[0]

   UpperCAmelCase					      =  image[0, -3:, -3:, -1]
   UpperCAmelCase					      =  image_from_tuple[0, -3:, -3:, -1]

   assert image.shape == (1, 6_4, 6_4, 3)
   UpperCAmelCase					      =  np.array([0.5_756, 0.6_118, 0.5_005, 0.5_041, 0.5_471, 0.4_726, 0.4_976, 0.4_865, 0.4_864]    )

   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 _UpperCamelCase	(						self		: List[str]    )    ->      Optional[int]:
   UpperCAmelCase					      =  "cpu"  # ensure determinism for the device-dependent torch.Generator
   UpperCAmelCase					      =  self.dummy_cond_unet
   UpperCAmelCase					      =  PNDMScheduler(skip_prk_steps=lowerCAmelCase__    )
   UpperCAmelCase					      =  self.dummy_vae
   UpperCAmelCase					      =  self.dummy_text_encoder
   UpperCAmelCase					      =  CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"    )

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

   UpperCAmelCase					      =  "A painting of a squirrel eating a burger"
   UpperCAmelCase					      =  torch.Generator(device=lowerCAmelCase__    ).manual_seed(0    )
   UpperCAmelCase					      =  sd_pipe([prompt]			,						generator=lowerCAmelCase__			,						guidance_scale=6.0			,						num_inference_steps=2			,						output_type="np"    )

   UpperCAmelCase					      =  output.images

   UpperCAmelCase					      =  torch.Generator(device=lowerCAmelCase__    ).manual_seed(0    )
   UpperCAmelCase					      =  sd_pipe(
       [prompt]			,						generator=lowerCAmelCase__			,						guidance_scale=6.0			,						num_inference_steps=2			,						output_type="np"			,						return_dict=lowerCAmelCase__			,						)[0]

   UpperCAmelCase					      =  image[0, -3:, -3:, -1]
   UpperCAmelCase					      =  image_from_tuple[0, -3:, -3:, -1]

   assert image.shape == (1, 6_4, 6_4, 3)
   UpperCAmelCase					      =  np.array([0.5_125, 0.5_716, 0.4_828, 0.5_060, 0.5_650, 0.4_768, 0.5_185, 0.4_895, 0.4_993]    )

   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 _UpperCamelCase	(						self		: Optional[Any]    )    ->      Optional[Any]:
   UpperCAmelCase					      =  StableDiffusionPipeline.from_pretrained(
       "hf-internal-testing/tiny-stable-diffusion-lms-pipe"			,						safety_checker=lowerCAmelCase__    )
   assert isinstance(lowerCAmelCase__			,						lowerCAmelCase__    )
   assert isinstance(pipe.scheduler			,						lowerCAmelCase__    )
   assert pipe.safety_checker is None

   UpperCAmelCase					      =  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__    )
     UpperCAmelCase					      =  StableDiffusionPipeline.from_pretrained(lowerCAmelCase__    )

   # sanity check that the pipeline still works
   assert pipe.safety_checker is None
   UpperCAmelCase					      =  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 _UpperCamelCase	(						self		: List[str]    )    ->      Optional[Any]:
   UpperCAmelCase					      =  self.dummy_cond_unet
   UpperCAmelCase					      =  PNDMScheduler(skip_prk_steps=lowerCAmelCase__    )
   UpperCAmelCase					      =  self.dummy_vae
   UpperCAmelCase					      =  self.dummy_text_encoder
   UpperCAmelCase					      =  CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"    )

   # put models in fp16
   UpperCAmelCase					      =  unet.half()
   UpperCAmelCase					      =  vae.half()
   UpperCAmelCase					      =  bert.half()

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

   UpperCAmelCase					      =  "A painting of a squirrel eating a burger"
   UpperCAmelCase					      =  sd_pipe([prompt]			,						num_inference_steps=2			,						output_type="np"    ).images

   assert image.shape == (1, 6_4, 6_4, 3)






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


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


 def _UpperCamelCase	(						self		: str    )    ->      Any:
   UpperCAmelCase					      =  StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5"			,						safety_checker=lowerCAmelCase__    )
   UpperCAmelCase					      =  LMSDiscreteScheduler.from_config(sd_pipe.scheduler.config    )
   UpperCAmelCase					      =  sd_pipe.to(lowerCAmelCase__    )
   sd_pipe.set_progress_bar_config(disable=lowerCAmelCase__    )

   UpperCAmelCase					      =  (
       "portrait of girl with smokey eyes makeup in abandoned hotel, grange clothes, redshift, wide high angle"
       " coloured polaroid photograph with flash, kodak film, hyper real, stunning moody cinematography, with"
       " anamorphic lenses, by maripol, fallen angels by wong kar - wai, style of suspiria and neon demon and"
       " children from bahnhof zoo, detailed "
   )
   UpperCAmelCase					      =  4_0_0_3_6_6_0_3_4_6
   UpperCAmelCase					      =  7

   # without safety guidance (sld_guidance_scale = 0)
   UpperCAmelCase					      =  torch.manual_seed(lowerCAmelCase__    )
   UpperCAmelCase					      =  sd_pipe(
       [prompt]			,						generator=lowerCAmelCase__			,						guidance_scale=lowerCAmelCase__			,						num_inference_steps=5_0			,						output_type="np"			,						width=5_1_2			,						height=5_1_2			,						sld_guidance_scale=0			,						)

   UpperCAmelCase					      =  output.images
   UpperCAmelCase					      =  image[0, -3:, -3:, -1]
   UpperCAmelCase					      =  [0.2_278, 0.2_231, 0.2_249, 0.2_333, 0.2_303, 0.1_885, 0.2_273, 0.2_144, 0.2_176]

   assert image.shape == (1, 5_1_2, 5_1_2, 3)

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

   # without safety guidance (strong configuration)
   UpperCAmelCase					      =  torch.manual_seed(lowerCAmelCase__    )
   UpperCAmelCase					      =  sd_pipe(
       [prompt]			,						generator=lowerCAmelCase__			,						guidance_scale=lowerCAmelCase__			,						num_inference_steps=5_0			,						output_type="np"			,						width=5_1_2			,						height=5_1_2			,						sld_guidance_scale=2_0_0_0			,						sld_warmup_steps=7			,						sld_threshold=0.025			,						sld_momentum_scale=0.5			,						sld_mom_beta=0.7			,						)

   UpperCAmelCase					      =  output.images
   UpperCAmelCase					      =  image[0, -3:, -3:, -1]
   UpperCAmelCase					      =  [0.2_383, 0.2_276, 0.236, 0.2_192, 0.2_186, 0.2_053, 0.1_971, 0.1_901, 0.1_719]

   assert image.shape == (1, 5_1_2, 5_1_2, 3)

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


 def _UpperCamelCase	(						self		: List[str]    )    ->      Tuple:
   UpperCAmelCase					      =  StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5"			,						safety_checker=lowerCAmelCase__    )
   UpperCAmelCase					      =  LMSDiscreteScheduler.from_config(sd_pipe.scheduler.config    )
   UpperCAmelCase					      =  sd_pipe.to(lowerCAmelCase__    )
   sd_pipe.set_progress_bar_config(disable=lowerCAmelCase__    )

   UpperCAmelCase					      =  "padme amidala taking a bath artwork, safe for work, no nudity"
   UpperCAmelCase					      =  2_7_3_4_9_7_1_7_5_5
   UpperCAmelCase					      =  7

   UpperCAmelCase					      =  torch.manual_seed(lowerCAmelCase__    )
   UpperCAmelCase					      =  sd_pipe(
       [prompt]			,						generator=lowerCAmelCase__			,						guidance_scale=lowerCAmelCase__			,						num_inference_steps=5_0			,						output_type="np"			,						width=5_1_2			,						height=5_1_2			,						sld_guidance_scale=0			,						)

   UpperCAmelCase					      =  output.images
   UpperCAmelCase					      =  image[0, -3:, -3:, -1]
   UpperCAmelCase					      =  [0.3_502, 0.3_622, 0.3_396, 0.3_642, 0.3_478, 0.3_318, 0.35, 0.3_348, 0.3_297]

   assert image.shape == (1, 5_1_2, 5_1_2, 3)

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

   UpperCAmelCase					      =  torch.manual_seed(lowerCAmelCase__    )
   UpperCAmelCase					      =  sd_pipe(
       [prompt]			,						generator=lowerCAmelCase__			,						guidance_scale=lowerCAmelCase__			,						num_inference_steps=5_0			,						output_type="np"			,						width=5_1_2			,						height=5_1_2			,						sld_guidance_scale=2_0_0_0			,						sld_warmup_steps=7			,						sld_threshold=0.025			,						sld_momentum_scale=0.5			,						sld_mom_beta=0.7			,						)

   UpperCAmelCase					      =  output.images
   UpperCAmelCase					      =  image[0, -3:, -3:, -1]
   UpperCAmelCase					      =  [0.5_531, 0.5_206, 0.4_895, 0.5_156, 0.5_182, 0.4_751, 0.4_802, 0.4_803, 0.4_443]

   assert image.shape == (1, 5_1_2, 5_1_2, 3)

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


 def _UpperCamelCase	(						self		: Optional[Any]    )    ->      Any:
   UpperCAmelCase					      =  StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5"    )
   UpperCAmelCase					      =  sd_pipe.to(lowerCAmelCase__    )
   sd_pipe.set_progress_bar_config(disable=lowerCAmelCase__    )

   UpperCAmelCase					      =  (
       "the four horsewomen of the apocalypse, painting by tom of finland, gaston bussiere, craig mullins, j. c."
       " leyendecker"
   )
   UpperCAmelCase					      =  1_0_4_4_3_5_5_2_3_4
   UpperCAmelCase					      =  1_2

   UpperCAmelCase					      =  torch.manual_seed(lowerCAmelCase__    )
   UpperCAmelCase					      =  sd_pipe(
       [prompt]			,						generator=lowerCAmelCase__			,						guidance_scale=lowerCAmelCase__			,						num_inference_steps=5_0			,						output_type="np"			,						width=5_1_2			,						height=5_1_2			,						sld_guidance_scale=0			,						)

   UpperCAmelCase					      =  output.images
   UpperCAmelCase					      =  image[0, -3:, -3:, -1]
   UpperCAmelCase					      =  np.array([0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]    )

   assert image.shape == (1, 5_1_2, 5_1_2, 3)

   assert np.abs(image_slice.flatten() - expected_slice    ).max() < 1e-7

   UpperCAmelCase					      =  torch.manual_seed(lowerCAmelCase__    )
   UpperCAmelCase					      =  sd_pipe(
       [prompt]			,						generator=lowerCAmelCase__			,						guidance_scale=lowerCAmelCase__			,						num_inference_steps=5_0			,						output_type="np"			,						width=5_1_2			,						height=5_1_2			,						sld_guidance_scale=2_0_0_0			,						sld_warmup_steps=7			,						sld_threshold=0.025			,						sld_momentum_scale=0.5			,						sld_mom_beta=0.7			,						)

   UpperCAmelCase					      =  output.images
   UpperCAmelCase					      =  image[0, -3:, -3:, -1]
   UpperCAmelCase					      =  np.array([0.5_818, 0.6_285, 0.6_835, 0.6_019, 0.625, 0.6_754, 0.6_096, 0.6_334, 0.6_561]    )
   assert image.shape == (1, 5_1_2, 5_1_2, 3)

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






def      _lowerCAmelCase(	__A			):
  assert column_title.isupper()
  UpperCAmelCase					      =  0
  UpperCAmelCase					      =  len(__A			) - 1
  UpperCAmelCase					      =  0

  while index >= 0:
    UpperCAmelCase					      =  (ord(column_title[index]			) - 64) * pow(26   ,       __A			)
    answer += value
    power += 1
    index -= 1

  return answer


if __name__ == "__main__":
      from doctest import testmod

      testmod()



