




"""simple docstring"""






import gc
import random
import unittest

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

from diffusers import AutoencoderKL, DDIMScheduler, DDPMScheduler, StableDiffusionUpscalePipeline, UNetaDConditionModel
from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu


enable_full_determinism()






class lowerCAmelCase__			(  unittest.TestCase		):






   '''simple docstring'''



   def       A_					(						self						):
       # clean up the VRAM after each test
       super().tearDown()
       gc.collect()
       torch.cuda.empty_cache()
   @property
   def       A_					(						self						):
       _lowerCamelCase  :    int					=					1
       _lowerCamelCase  :    List[Any]					=					3
       _lowerCamelCase  :    str					=					(32, 32)

       _lowerCamelCase  :    List[Any]					=					floats_tensor((batch_size, num_channels) + sizes						,   rng=random.Random(0						)						).to(lowercase						)
       return image
   @property
   def       A_					(						self						):
       torch.manual_seed(0						)
       _lowerCamelCase  :    Optional[Any]					=					UNetaDConditionModel(
           block_out_channels=(32, 32, 64)						,   layers_per_block=2						,   sample_size=32						,   in_channels=7						,   out_channels=4						,   down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D', 'CrossAttnDownBlock2D')						,   up_block_types=('CrossAttnUpBlock2D', 'CrossAttnUpBlock2D', 'UpBlock2D')						,   cross_attention_dim=32						,   attention_head_dim=8						,   use_linear_projection=lowercase						,   only_cross_attention=(True, True, False)						,   num_class_embeds=100						,   )
       return model
   @property
   def       A_					(						self						):
       torch.manual_seed(0						)
       _lowerCamelCase  :    Dict					=					AutoencoderKL(
           block_out_channels=[32, 32, 64]						,   in_channels=3						,   out_channels=3						,   down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D', 'DownEncoderBlock2D']						,   up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D', 'UpDecoderBlock2D']						,   latent_channels=4						,   )
       return model
   @property
   def       A_					(						self						):
       torch.manual_seed(0						)
       _lowerCamelCase  :    int					=					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						,   hidden_act='gelu'						,   projection_dim=512						,   )
       return CLIPTextModel(lowercase						)
   def       A_					(						self						):
       _lowerCamelCase  :    List[str]					=					'cpu'  # ensure determinism for the device-dependent torch.Generator
       _lowerCamelCase  :    Any					=					self.dummy_cond_unet_upscale
       _lowerCamelCase  :    str					=					DDPMScheduler()
       _lowerCamelCase  :    Dict					=					DDIMScheduler(prediction_type='v_prediction'						)
       _lowerCamelCase  :    Optional[int]					=					self.dummy_vae
       _lowerCamelCase  :    Tuple					=					self.dummy_text_encoder
       _lowerCamelCase  :    Optional[Any]					=					CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'						)

       _lowerCamelCase  :    Optional[Any]					=					self.dummy_image.cpu().permute(0						,   2						,   3						,   1						)[0]
       _lowerCamelCase  :    str					=					Image.fromarray(np.uinta(lowercase						)						).convert('RGB'						).resize((64, 64)						)

       # make sure here that pndm scheduler skips prk
       _lowerCamelCase  :    Any					=					StableDiffusionUpscalePipeline(
           unet=lowercase						,   low_res_scheduler=lowercase						,   scheduler=lowercase						,   vae=lowercase						,   text_encoder=lowercase						,   tokenizer=lowercase						,   max_noise_level=350						,   )
       _lowerCamelCase  :    List[Any]					=					sd_pipe.to(lowercase						)
       sd_pipe.set_progress_bar_config(disable=lowercase						)

       _lowerCamelCase  :    Union[str, Any]					=					'A painting of a squirrel eating a burger'
       _lowerCamelCase  :    Optional[int]					=					torch.Generator(device=lowercase						).manual_seed(0						)
       _lowerCamelCase  :    Any					=					sd_pipe(
           [prompt]						,   image=lowercase						,   generator=lowercase						,   guidance_scale=6.0						,   noise_level=20						,   num_inference_steps=2						,   output_type='np'						,   )

       _lowerCamelCase  :    Optional[int]					=					output.images

       _lowerCamelCase  :    List[str]					=					torch.Generator(device=lowercase						).manual_seed(0						)
       _lowerCamelCase  :    List[Any]					=					sd_pipe(
           [prompt]						,   image=lowercase						,   generator=lowercase						,   guidance_scale=6.0						,   noise_level=20						,   num_inference_steps=2						,   output_type='np'						,   return_dict=lowercase						,   )[0]

       _lowerCamelCase  :    str					=					image[0, -3:, -3:, -1]
       _lowerCamelCase  :    str					=					image_from_tuple[0, -3:, -3:, -1]

       _lowerCamelCase  :    str					=					low_res_image.size[0] * 4
       assert image.shape == (1, expected_height_width, expected_height_width, 3)
       _lowerCamelCase  :    Dict					=					np.array([0.31_13, 0.39_10, 0.42_72, 0.48_59, 0.50_61, 0.46_52, 0.53_62, 0.57_15, 0.56_61]						)

       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       A_					(						self						):
       _lowerCamelCase  :    Optional[int]					=					'cpu'  # ensure determinism for the device-dependent torch.Generator
       _lowerCamelCase  :    Dict					=					self.dummy_cond_unet_upscale
       _lowerCamelCase  :    Dict					=					DDPMScheduler()
       _lowerCamelCase  :    Tuple					=					DDIMScheduler(prediction_type='v_prediction'						)
       _lowerCamelCase  :    Dict					=					self.dummy_vae
       _lowerCamelCase  :    int					=					self.dummy_text_encoder
       _lowerCamelCase  :    List[str]					=					CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'						)

       _lowerCamelCase  :    Optional[int]					=					self.dummy_image.cpu().permute(0						,   2						,   3						,   1						)[0]
       _lowerCamelCase  :    Optional[Any]					=					Image.fromarray(np.uinta(lowercase						)						).convert('RGB'						).resize((64, 64)						)

       # make sure here that pndm scheduler skips prk
       _lowerCamelCase  :    Any					=					StableDiffusionUpscalePipeline(
           unet=lowercase						,   low_res_scheduler=lowercase						,   scheduler=lowercase						,   vae=lowercase						,   text_encoder=lowercase						,   tokenizer=lowercase						,   max_noise_level=350						,   )
       _lowerCamelCase  :    Dict					=					sd_pipe.to(lowercase						)
       sd_pipe.set_progress_bar_config(disable=lowercase						)

       _lowerCamelCase  :    List[str]					=					'A painting of a squirrel eating a burger'
       _lowerCamelCase  :    Tuple					=					sd_pipe(
           2 * [prompt]						,   image=2 * [low_res_image]						,   guidance_scale=6.0						,   noise_level=20						,   num_inference_steps=2						,   output_type='np'						,   )
       _lowerCamelCase  :    Dict					=					output.images
       assert image.shape[0] == 2

       _lowerCamelCase  :    int					=					torch.Generator(device=lowercase						).manual_seed(0						)
       _lowerCamelCase  :    Union[str, Any]					=					sd_pipe(
           [prompt]						,   image=lowercase						,   generator=lowercase						,   num_images_per_prompt=2						,   guidance_scale=6.0						,   noise_level=20						,   num_inference_steps=2						,   output_type='np'						,   )
       _lowerCamelCase  :    Optional[int]					=					output.images
       assert image.shape[0] == 2






   @unittest.skipIf(torch_device != 'cuda'						,   'This test requires a GPU'						)
   def       A_					(						self						):
       _lowerCamelCase  :    Dict					=					self.dummy_cond_unet_upscale
       _lowerCamelCase  :    str					=					DDPMScheduler()
       _lowerCamelCase  :    Dict					=					DDIMScheduler(prediction_type='v_prediction'						)
       _lowerCamelCase  :    Any					=					self.dummy_vae
       _lowerCamelCase  :    Dict					=					self.dummy_text_encoder
       _lowerCamelCase  :    List[Any]					=					CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'						)

       _lowerCamelCase  :    List[str]					=					self.dummy_image.cpu().permute(0						,   2						,   3						,   1						)[0]
       _lowerCamelCase  :    List[str]					=					Image.fromarray(np.uinta(lowercase						)						).convert('RGB'						).resize((64, 64)						)

       # put models in fp16, except vae as it overflows in fp16
       _lowerCamelCase  :    Dict					=					unet.half()
       _lowerCamelCase  :    Optional[int]					=					text_encoder.half()

       # make sure here that pndm scheduler skips prk
       _lowerCamelCase  :    Optional[int]					=					StableDiffusionUpscalePipeline(
           unet=lowercase						,   low_res_scheduler=lowercase						,   scheduler=lowercase						,   vae=lowercase						,   text_encoder=lowercase						,   tokenizer=lowercase						,   max_noise_level=350						,   )
       _lowerCamelCase  :    str					=					sd_pipe.to(lowercase						)
       sd_pipe.set_progress_bar_config(disable=lowercase						)

       _lowerCamelCase  :    Optional[Any]					=					'A painting of a squirrel eating a burger'
       _lowerCamelCase  :    int					=					torch.manual_seed(0						)
       _lowerCamelCase  :    str					=					sd_pipe(
           [prompt]						,   image=lowercase						,   generator=lowercase						,   num_inference_steps=2						,   output_type='np'						,   ).images

       _lowerCamelCase  :    List[Any]					=					low_res_image.size[0] * 4
       assert image.shape == (1, expected_height_width, expected_height_width, 3)






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






   '''simple docstring'''



   def       A_					(						self						):
       # clean up the VRAM after each test
       super().tearDown()
       gc.collect()
       torch.cuda.empty_cache()
   def       A_					(						self						):
       _lowerCamelCase  :    Optional[int]					=					load_image(
           'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
           '/sd2-upscale/low_res_cat.png'						)
       _lowerCamelCase  :    Optional[Any]					=					load_numpy(
           'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd2-upscale'
           '/upsampled_cat.npy'						)

       _lowerCamelCase  :    int					=					'stabilityai/stable-diffusion-x4-upscaler'
       _lowerCamelCase  :    Tuple					=					StableDiffusionUpscalePipeline.from_pretrained(lowercase						)
       pipe.to(lowercase						)
       pipe.set_progress_bar_config(disable=lowercase						)
       pipe.enable_attention_slicing()

       _lowerCamelCase  :    List[Any]					=					'a cat sitting on a park bench'

       _lowerCamelCase  :    Union[str, Any]					=					torch.manual_seed(0						)
       _lowerCamelCase  :    Tuple					=					pipe(
           prompt=lowercase						,   image=lowercase						,   generator=lowercase						,   output_type='np'						,   )
       _lowerCamelCase  :    Optional[int]					=					output.images[0]

       assert image.shape == (512, 512, 3)
       assert np.abs(expected_image - image						).max() < 1E-3
   def       A_					(						self						):
       _lowerCamelCase  :    int					=					load_image(
           'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
           '/sd2-upscale/low_res_cat.png'						)
       _lowerCamelCase  :    Optional[Any]					=					load_numpy(
           'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd2-upscale'
           '/upsampled_cat_fp16.npy'						)

       _lowerCamelCase  :    Optional[Any]					=					'stabilityai/stable-diffusion-x4-upscaler'
       _lowerCamelCase  :    int					=					StableDiffusionUpscalePipeline.from_pretrained(
           lowercase						,   torch_dtype=torch.floataa						,   )
       pipe.to(lowercase						)
       pipe.set_progress_bar_config(disable=lowercase						)
       pipe.enable_attention_slicing()

       _lowerCamelCase  :    Optional[Any]					=					'a cat sitting on a park bench'

       _lowerCamelCase  :    List[Any]					=					torch.manual_seed(0						)
       _lowerCamelCase  :    List[Any]					=					pipe(
           prompt=lowercase						,   image=lowercase						,   generator=lowercase						,   output_type='np'						,   )
       _lowerCamelCase  :    int					=					output.images[0]

       assert image.shape == (512, 512, 3)
       assert np.abs(expected_image - image						).max() < 5E-1






   def       A_					(						self						):
       torch.cuda.empty_cache()
       torch.cuda.reset_max_memory_allocated()
       torch.cuda.reset_peak_memory_stats()

       _lowerCamelCase  :    int					=					load_image(
           'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
           '/sd2-upscale/low_res_cat.png'						)

       _lowerCamelCase  :    int					=					'stabilityai/stable-diffusion-x4-upscaler'
       _lowerCamelCase  :    List[Any]					=					StableDiffusionUpscalePipeline.from_pretrained(
           lowercase						,   torch_dtype=torch.floataa						,   )
       pipe.to(lowercase						)
       pipe.set_progress_bar_config(disable=lowercase						)
       pipe.enable_attention_slicing(1						)
       pipe.enable_sequential_cpu_offload()

       _lowerCamelCase  :    List[str]					=					'a cat sitting on a park bench'

       _lowerCamelCase  :    int					=					torch.manual_seed(0						)
       _lowerCamelCase  :    Tuple					=					pipe(
           prompt=lowercase						,   image=lowercase						,   generator=lowercase						,   num_inference_steps=5						,   output_type='np'						,   )

       _lowerCamelCase  :    Union[str, Any]					=					torch.cuda.max_memory_allocated()
       # make sure that less than 2.9 GB is allocated
       assert mem_bytes < 2.9 * 10**9





"""simple docstring"""






from dataclasses import dataclass
from typing import List, Optional, Union

import numpy as np
import torch

from ...utils import BaseOutput, OptionalDependencyNotAvailable, is_torch_available, is_transformers_available






@dataclass
class lowerCAmelCase__			(  lowercase		):






			'''simple docstring'''



			lowerCamelCase__   =    42


try:
			if not (is_transformers_available() and is_torch_available()):
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			from ...utils.dummy_torch_and_transformers_objects import *  # noqa F403
else:
			from .pipeline_text_to_video_synth import TextToVideoSDPipeline
			from .pipeline_text_to_video_synth_imgaimg import VideoToVideoSDPipeline  # noqa: F401
			from .pipeline_text_to_video_zero import TextToVideoZeroPipeline