






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 					lowerCAmelCase (     self :		Union[str, Any]							)	->     List[str]:


												"""simple docstring"""

												super().tearDown()
												gc.collect()
												torch.cuda.empty_cache()



					@property
					def 					lowerCAmelCase (     self :		Any							)	->     str:


												"""simple docstring"""

												__lowercase					:							Dict			=   1
												__lowercase					:							Tuple			=   3
												__lowercase					:							List[Any]			=   (32, 32)

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



					@property
					def 					lowerCAmelCase (     self :		Optional[Any]							)	->     Union[str, Any]:


												"""simple docstring"""

												torch.manual_seed(0							)
												__lowercase					:							Union[str, 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=__a						,   only_cross_attention=(True, True, False)						,   num_class_embeds=100						,   )
												return model



					@property
					def 					lowerCAmelCase (     self :		Optional[Any]							)	->     Union[str, Any]:


												"""simple docstring"""

												torch.manual_seed(0							)
												__lowercase					:							int			=   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 					lowerCAmelCase (     self :		Optional[Any]							)	->     Dict:


												"""simple docstring"""

												torch.manual_seed(0							)
												__lowercase					:							str			=   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(__a							)



					def 					lowerCAmelCase (     self :		Any							)	->     Optional[int]:


												"""simple docstring"""

												__lowercase					:							List[Any]			=   """cpu"""  # ensure determinism for the device-dependent torch.Generator
												__lowercase					:							List[str]			=   self.dummy_cond_unet_upscale
												__lowercase					:							Union[str, Any]			=   DDPMScheduler()
												__lowercase					:							List[str]			=   DDIMScheduler(prediction_type="""v_prediction"""							)
												__lowercase					:							List[str]			=   self.dummy_vae
												__lowercase					:							Dict			=   self.dummy_text_encoder
												__lowercase					:							Optional[Any]			=   CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""							)

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

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

												__lowercase					:							Dict			=   """A painting of a squirrel eating a burger"""
												__lowercase					:							Optional[Any]			=   torch.Generator(device=__a							).manual_seed(0							)
												__lowercase					:							List[Any]			=   sd_pipe(
												    [prompt]						,   image=__a						,   generator=__a						,   guidance_scale=6.0						,   noise_level=20						,   num_inference_steps=2						,   output_type="""np"""						,   )

												__lowercase					:							Optional[int]			=   output.images

												__lowercase					:							Union[str, Any]			=   torch.Generator(device=__a							).manual_seed(0							)
												__lowercase					:							str			=   sd_pipe(
												    [prompt]						,   image=__a						,   generator=__a						,   guidance_scale=6.0						,   noise_level=20						,   num_inference_steps=2						,   output_type="""np"""						,   return_dict=__a						,   )[0]

												__lowercase					:							int			=   image[0, -3:, -3:, -1]
												__lowercase					:							Union[str, Any]			=   image_from_tuple[0, -3:, -3:, -1]

												__lowercase					:							List[str]			=   low_res_image.size[0] * 4
												assert image.shape == (1, expected_height_width, expected_height_width, 3)
												__lowercase					:							str			=   np.array([0.3113, 0.3910, 0.4272, 0.4859, 0.5061, 0.4652, 0.5362, 0.5715, 0.5661]							)

												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 					lowerCAmelCase (     self :		str							)	->     List[Any]:


												"""simple docstring"""

												__lowercase					:							Dict			=   """cpu"""  # ensure determinism for the device-dependent torch.Generator
												__lowercase					:							List[Any]			=   self.dummy_cond_unet_upscale
												__lowercase					:							Tuple			=   DDPMScheduler()
												__lowercase					:							int			=   DDIMScheduler(prediction_type="""v_prediction"""							)
												__lowercase					:							Optional[int]			=   self.dummy_vae
												__lowercase					:							str			=   self.dummy_text_encoder
												__lowercase					:							Tuple			=   CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""							)

												__lowercase					:							Optional[Any]			=   self.dummy_image.cpu().permute(0						,   2						,   3						,   1							)[0]
												__lowercase					:							Dict			=   Image.fromarray(np.uinta(__a							)							).convert("""RGB"""							).resize((64, 64)							)

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

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

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



					@unittest.skipIf(torch_device != """cuda"""						,   """This test requires a GPU"""							)
					def 					lowerCAmelCase (     self :		Any							)	->     Union[str, Any]:


												"""simple docstring"""

												__lowercase					:							List[Any]			=   self.dummy_cond_unet_upscale
												__lowercase					:							Any			=   DDPMScheduler()
												__lowercase					:							Dict			=   DDIMScheduler(prediction_type="""v_prediction"""							)
												__lowercase					:							List[Any]			=   self.dummy_vae
												__lowercase					:							int			=   self.dummy_text_encoder
												__lowercase					:							Optional[Any]			=   CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""							)

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

												# put models in fp16, except vae as it overflows in fp16
												__lowercase					:							Tuple			=   unet.half()
												__lowercase					:							List[str]			=   text_encoder.half()

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

												__lowercase					:							Dict			=   """A painting of a squirrel eating a burger"""
												__lowercase					:							int			=   torch.manual_seed(0							)
												__lowercase					:							List[str]			=   sd_pipe(
												    [prompt]						,   image=__a						,   generator=__a						,   num_inference_steps=2						,   output_type="""np"""						,   ).images

												__lowercase					:							int			=   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 					lowerCAmelCase (     self :		int							)	->     Union[str, Any]:


												"""simple docstring"""

												super().tearDown()
												gc.collect()
												torch.cuda.empty_cache()



					def 					lowerCAmelCase (     self :		Tuple							)	->     List[str]:


												"""simple docstring"""

												__lowercase					:							Optional[Any]			=   load_image(
												    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
												    """/sd2-upscale/low_res_cat.png"""							)
												__lowercase					:							Union[str, Any]			=   load_numpy(
												    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd2-upscale"""
												    """/upsampled_cat.npy"""							)

												__lowercase					:							Any			=   """stabilityai/stable-diffusion-x4-upscaler"""
												__lowercase					:							Dict			=   StableDiffusionUpscalePipeline.from_pretrained(__a							)
												pipe.to(__a							)
												pipe.set_progress_bar_config(disable=__a							)
												pipe.enable_attention_slicing()

												__lowercase					:							List[str]			=   """a cat sitting on a park bench"""

												__lowercase					:							Optional[Any]			=   torch.manual_seed(0							)
												__lowercase					:							Tuple			=   pipe(
												    prompt=__a						,   image=__a						,   generator=__a						,   output_type="""np"""						,   )
												__lowercase					:							Optional[int]			=   output.images[0]

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



					def 					lowerCAmelCase (     self :		str							)	->     str:


												"""simple docstring"""

												__lowercase					:							Tuple			=   load_image(
												    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
												    """/sd2-upscale/low_res_cat.png"""							)
												__lowercase					:							Optional[int]			=   load_numpy(
												    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd2-upscale"""
												    """/upsampled_cat_fp16.npy"""							)

												__lowercase					:							Optional[int]			=   """stabilityai/stable-diffusion-x4-upscaler"""
												__lowercase					:							int			=   StableDiffusionUpscalePipeline.from_pretrained(
												    __a						,   torch_dtype=torch.floataa						,   )
												pipe.to(__a							)
												pipe.set_progress_bar_config(disable=__a							)
												pipe.enable_attention_slicing()

												__lowercase					:							List[str]			=   """a cat sitting on a park bench"""

												__lowercase					:							List[Any]			=   torch.manual_seed(0							)
												__lowercase					:							List[Any]			=   pipe(
												    prompt=__a						,   image=__a						,   generator=__a						,   output_type="""np"""						,   )
												__lowercase					:							Optional[Any]			=   output.images[0]

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



					def 					lowerCAmelCase (     self :		str							)	->     Dict:


												"""simple docstring"""

												torch.cuda.empty_cache()
												torch.cuda.reset_max_memory_allocated()
												torch.cuda.reset_peak_memory_stats()

												__lowercase					:							Tuple			=   load_image(
												    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
												    """/sd2-upscale/low_res_cat.png"""							)

												__lowercase					:							List[str]			=   """stabilityai/stable-diffusion-x4-upscaler"""
												__lowercase					:							Any			=   StableDiffusionUpscalePipeline.from_pretrained(
												    __a						,   torch_dtype=torch.floataa						,   )
												pipe.to(__a							)
												pipe.set_progress_bar_config(disable=__a							)
												pipe.enable_attention_slicing(1							)
												pipe.enable_sequential_cpu_offload()

												__lowercase					:							Optional[int]			=   """a cat sitting on a park bench"""

												__lowercase					:							Dict			=   torch.manual_seed(0							)
												__lowercase					:							Union[str, Any]			=   pipe(
												    prompt=__a						,   image=__a						,   generator=__a						,   num_inference_steps=5						,   output_type="""np"""						,   )

												__lowercase					:							str			=   torch.cuda.max_memory_allocated()
												# make sure that less than 2.9 GB is allocated
												assert mem_bytes < 2.9 * 10**9







lowerCamelCase       :       Optional[Any]        =				'''ABCDEFGHIJKLMNOPQRSTUVWXYZ'''
def 					snake_case_						(   ):
							__lowercase					:							List[str]			=   input("""Enter message: """					)
							__lowercase					:							int			=   input("""Enter key [alphanumeric]: """					)
							__lowercase					:							Optional[Any]			=   input("""Encrypt/Decrypt [e/d]: """					)

							if mode.lower().startswith("""e"""					):
														__lowercase					:							Optional[int]			=   """encrypt"""
														__lowercase					:							Dict			=   encrypt_message(lowerCAmelCase_				,				lowerCAmelCase_					)
							elif mode.lower().startswith("""d"""					):
														__lowercase					:							Union[str, Any]			=   """decrypt"""
														__lowercase					:							Optional[int]			=   decrypt_message(lowerCAmelCase_				,				lowerCAmelCase_					)

							print(F"\n{mode.title()}ed message:"					)
							print(lowerCAmelCase_					)
def 					snake_case_						(   lowerCAmelCase_				:  str				,				lowerCAmelCase_				:  str					):
							return translate_message(lowerCAmelCase_				,				lowerCAmelCase_				,				"""encrypt"""					)
def 					snake_case_						(   lowerCAmelCase_				:  str				,				lowerCAmelCase_				:  str					):
							return translate_message(lowerCAmelCase_				,				lowerCAmelCase_				,				"""decrypt"""					)
def 					snake_case_						(   lowerCAmelCase_				:  str				,				lowerCAmelCase_				:  str				,				lowerCAmelCase_				:  str					):
							__lowercase					:							Union[str, Any]			=   []
							__lowercase					:							Tuple			=   0
							__lowercase					:							Dict			=   key.upper()

							for symbol in message:
														__lowercase					:							Optional[Any]			=   LETTERS.find(symbol.upper()					)
														if num != -1:
																					if mode == "encrypt":
																												num += LETTERS.find(key[key_index]					)
																					elif mode == "decrypt":
																												num -= LETTERS.find(key[key_index]					)

																					num %= len(lowerCAmelCase_					)

																					if symbol.isupper():
																												translated.append(LETTERS[num]					)
																					elif symbol.islower():
																												translated.append(LETTERS[num].lower()					)

																					key_index += 1
																					if key_index == len(lowerCAmelCase_					):
																												__lowercase					:							str			=   0
														else:
																					translated.append(lowerCAmelCase_					)
							return "".join(lowerCAmelCase_					)


if __name__ == "__main__":
	main()