






"""simple docstring"""







import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    EulerAncestralDiscreteScheduler,
    PNDMScheduler,
    StableDiffusionModelEditingPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu, skip_mps

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


enable_full_determinism()


@skip_mps
class     __UpperCAmelCase(   SCREAMING_SNAKE_CASE__  ,  SCREAMING_SNAKE_CASE__  ,  SCREAMING_SNAKE_CASE__  ,  unittest.TestCase							):




						"""simple docstring"""




						__lowerCamelCase				       =					StableDiffusionModelEditingPipeline
						__lowerCamelCase				       =					TEXT_TO_IMAGE_PARAMS
						__lowerCamelCase				       =					TEXT_TO_IMAGE_BATCH_PARAMS
						__lowerCamelCase				       =					TEXT_TO_IMAGE_IMAGE_PARAMS
						__lowerCamelCase				       =					TEXT_TO_IMAGE_IMAGE_PARAMS




						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												torch.manual_seed(0			)
												lowercase__				:      Optional[int]=       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       ,  )
												lowercase__				:      Any=       DDIMScheduler()
												torch.manual_seed(0			)
												lowercase__				:      Any=       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       ,  )
												torch.manual_seed(0			)
												lowercase__				:      List[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       ,  )
												lowercase__				:      Optional[Any]=       CLIPTextModel(snake_case__			)
												lowercase__				:      int=       CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"			)

												lowercase__				:      Union[str, Any]=       {
												    "unet": unet,
												    "scheduler": scheduler,
												    "vae": vae,
												    "text_encoder": text_encoder,
												    "tokenizer": tokenizer,
												    "safety_checker": None,
												    "feature_extractor": None,
												}
												return components




						def 		UpperCAmelCase_       (   self       ,  snake_case__       ,  snake_case__=0			):
												'''simple docstring'''
												lowercase__				:      Optional[int]=       torch.manual_seed(snake_case__			)
												lowercase__				:      Tuple=       {
												    "prompt": "A field of roses",
												    "generator": generator,
												    # Setting height and width to None to prevent OOMs on CPU.
												    "height": None,
												    "width": None,
												    "num_inference_steps": 2,
												    "guidance_scale": 6.0,
												    "output_type": "numpy",
												}
												return inputs




						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												lowercase__				:      Any=       "cpu"  # ensure determinism for the device-dependent torch.Generator
												lowercase__				:      Tuple=       self.get_dummy_components()
												lowercase__				:      List[str]=       StableDiffusionModelEditingPipeline(**snake_case__			)
												lowercase__				:      Dict=       sd_pipe.to(snake_case__			)
												sd_pipe.set_progress_bar_config(disable=snake_case__			)

												lowercase__				:      Union[str, Any]=       self.get_dummy_inputs(snake_case__			)
												lowercase__				:      Optional[Any]=       sd_pipe(**snake_case__			).images
												lowercase__				:      int=       image[0, -3:, -3:, -1]
												assert image.shape == (1, 64, 64, 3)

												lowercase__				:      List[str]=       np.array([0.47_55, 0.51_32, 0.49_76, 0.39_04, 0.35_54, 0.47_65, 0.51_39, 0.51_58, 0.48_89]			)

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




						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												lowercase__				:      Optional[int]=       "cpu"  # ensure determinism for the device-dependent torch.Generator
												lowercase__				:      str=       self.get_dummy_components()
												lowercase__				:      Tuple=       StableDiffusionModelEditingPipeline(**snake_case__			)
												lowercase__				:      Union[str, Any]=       sd_pipe.to(snake_case__			)
												sd_pipe.set_progress_bar_config(disable=snake_case__			)

												lowercase__				:      Optional[int]=       self.get_dummy_inputs(snake_case__			)
												lowercase__				:      int=       "french fries"
												lowercase__				:      Optional[int]=       sd_pipe(**snake_case__       ,  negative_prompt=snake_case__			)
												lowercase__				:      Union[str, Any]=       output.images
												lowercase__				:      str=       image[0, -3:, -3:, -1]

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

												lowercase__				:      str=       np.array([0.49_92, 0.51_01, 0.50_04, 0.39_49, 0.36_04, 0.47_35, 0.52_16, 0.52_04, 0.49_13]			)

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




						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												lowercase__				:      Dict=       "cpu"  # ensure determinism for the device-dependent torch.Generator
												lowercase__				:      Dict=       self.get_dummy_components()
												lowercase__				:      str=       EulerAncestralDiscreteScheduler(
												    beta_start=0.0_00_85       ,  beta_end=0.0_12       ,  beta_schedule="scaled_linear"			)
												lowercase__				:      int=       StableDiffusionModelEditingPipeline(**snake_case__			)
												lowercase__				:      List[Any]=       sd_pipe.to(snake_case__			)
												sd_pipe.set_progress_bar_config(disable=snake_case__			)

												lowercase__				:      Dict=       self.get_dummy_inputs(snake_case__			)
												lowercase__				:      Optional[Any]=       sd_pipe(**snake_case__			).images
												lowercase__				:      Any=       image[0, -3:, -3:, -1]

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

												lowercase__				:      Any=       np.array([0.47_47, 0.53_72, 0.47_79, 0.49_82, 0.55_43, 0.48_16, 0.52_38, 0.49_04, 0.50_27]			)

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




						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												lowercase__				:      Union[str, Any]=       "cpu"  # ensure determinism for the device-dependent torch.Generator
												lowercase__				:      Dict=       self.get_dummy_components()
												lowercase__				:      int=       PNDMScheduler()
												lowercase__				:      Optional[Any]=       StableDiffusionModelEditingPipeline(**snake_case__			)
												lowercase__				:      Tuple=       sd_pipe.to(snake_case__			)
												sd_pipe.set_progress_bar_config(disable=snake_case__			)

												lowercase__				:      List[Any]=       self.get_dummy_inputs(snake_case__			)
												# the pipeline does not expect pndm so test if it raises error.
												with self.assertRaises(snake_case__			):
																		lowercase__				:      List[str]=       sd_pipe(**snake_case__			).images




						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												super().test_inference_batch_single_identical(expected_max_diff=5e-3			)




						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												super().test_attention_slicing_forward_pass(expected_max_diff=5e-3			)


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




						"""simple docstring"""




						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												super().tearDown()
												gc.collect()
												torch.cuda.empty_cache()




						def 		UpperCAmelCase_       (   self       ,  snake_case__=0			):
												'''simple docstring'''
												lowercase__				:      Dict=       torch.manual_seed(snake_case__			)
												lowercase__				:      Union[str, Any]=       {
												    "prompt": "A field of roses",
												    "generator": generator,
												    "num_inference_steps": 3,
												    "guidance_scale": 7.5,
												    "output_type": "numpy",
												}
												return inputs




						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												lowercase__				:      Optional[int]=       "CompVis/stable-diffusion-v1-4"
												lowercase__				:      int=       StableDiffusionModelEditingPipeline.from_pretrained(snake_case__       ,  safety_checker=snake_case__			)
												pipe.to(snake_case__			)
												pipe.set_progress_bar_config(disable=snake_case__			)
												pipe.enable_attention_slicing()

												lowercase__				:      List[Any]=       self.get_inputs()
												lowercase__				:      int=       pipe(**snake_case__			).images
												lowercase__				:      Optional[Any]=       image[0, -3:, -3:, -1].flatten()

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

												lowercase__				:      Tuple=       np.array(
												    [0.6_74_94_96, 0.6_38_64_53, 0.51_44_32_67, 0.66_09_49_05, 0.61_92_12_15, 0.5_49_13_32, 0.5_74_44_17, 0.58_07_51_06, 0.5_17_46_58]			)

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

												# make sure image changes after editing
												pipe.edit_model("A pack of roses"       ,  "A pack of blue roses"			)

												lowercase__				:      int=       pipe(**snake_case__			).images
												lowercase__				:      int=       image[0, -3:, -3:, -1].flatten()

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

												assert np.abs(expected_slice - image_slice			).max() > 1e-1




						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												torch.cuda.empty_cache()
												torch.cuda.reset_max_memory_allocated()
												torch.cuda.reset_peak_memory_stats()

												lowercase__				:      Optional[Any]=       "CompVis/stable-diffusion-v1-4"
												lowercase__				:      str=       DDIMScheduler.from_pretrained(snake_case__       ,  subfolder="scheduler"			)
												lowercase__				:      List[str]=       StableDiffusionModelEditingPipeline.from_pretrained(
												    snake_case__       ,  scheduler=snake_case__       ,  safety_checker=snake_case__			)
												lowercase__				:      int=       pipe.to(snake_case__			)
												pipe.set_progress_bar_config(disable=snake_case__			)
												pipe.enable_attention_slicing(1			)
												pipe.enable_sequential_cpu_offload()

												lowercase__				:      List[str]=       self.get_inputs()
												lowercase__				:      Optional[int]=       pipe(**snake_case__			)

												lowercase__				:      int=       torch.cuda.max_memory_allocated()
												# make sure that less than 4.4 GB is allocated
												assert mem_bytes < 4.4 * 10**9














def    lowerCAmelCase__		(			_a				:	str     ,					_a				:	int = 13			):
		snake_case_ :							List[Any]         =				""
		for c in s:
				if "A" <= c <= "Z":
						out += chr(ord("A"			) + (ord(_a			) - ord("A"			) + n) % 26			)
				elif "a" <= c <= "z":
						out += chr(ord("a"			) + (ord(_a			) - ord("a"			) + n) % 26			)
				else:
						out += c
		return out

def    lowerCAmelCase__		(			):
		snake_case_ :							int         =				input("Enter message: "			)

		snake_case_ :							List[Any]         =				dencrypt(_a     ,					13			)
		print("Encryption:"     ,					_a			)

		snake_case_ :							int         =				dencrypt(_a     ,					13			)
		print("Decryption: "     ,					_a			)


if __name__ == "__main__":
							import doctest

							doctest.testmod()
							main()
