






"""simple docstring"""

def 	__lowerCamelCase			(						__UpperCamelCase   , __UpperCamelCase = 13 )		->					str:

		"""simple docstring"""







		lowerCAmelCase_     :							str             =    ""
		for c in s:
				if "A" <= c <= "Z":
						out += chr(ord("A" ) + (ord(_UpperCamelCase ) - ord("A" ) + n) % 26 )
				elif "a" <= c <= "z":
						out += chr(ord("a" ) + (ord(_UpperCamelCase ) - ord("a" ) + n) % 26 )
				else:
						out += c
		return out

def 	__lowerCamelCase			(						)		->					None:

		"""simple docstring"""







		lowerCAmelCase_     :							Any             =    input("Enter message: " )

		lowerCAmelCase_     :							int             =    dencrypt(_UpperCamelCase   , 13 )
		print("Encryption:"   , _UpperCamelCase )

		lowerCAmelCase_     :							int             =    dencrypt(_UpperCamelCase   , 13 )
		print("Decryption: "   , _UpperCamelCase )


if __name__ == "__main__":
					import doctest

					doctest.testmod()
					main()














"""simple docstring"""

import gc
import random
import unittest

import numpy as np
import torch
from PIL import Image
from transformers import CLIPImageProcessor, CLIPVisionConfig, CLIPVisionModelWithProjection

from diffusers import (
    AutoencoderKL,
    DPMSolverMultistepScheduler,
    PNDMScheduler,
    StableDiffusionImageVariationPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import floats_tensor, load_image, load_numpy, nightly, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import IMAGE_VARIATION_BATCH_PARAMS, IMAGE_VARIATION_PARAMS
from ..test_pipelines_common import PipelineKarrasSchedulerTesterMixin, PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()


class 	__lowerCamelCase       (				A__				,							A__				,							A__				,							unittest.TestCase    ):





		'''simple docstring'''






		a_			:       Union[str, Any]      =							StableDiffusionImageVariationPipeline
		a_			:       Tuple      =							IMAGE_VARIATION_PARAMS
		a_			:       Optional[Any]      =							IMAGE_VARIATION_BATCH_PARAMS
		a_			:       int      =							frozenset([]    )
		# TO-DO: update image_params once pipeline is refactored with VaeImageProcessor.preprocess
		a_			:       Optional[int]      =							frozenset([]    )





		def      lowerCamelCase (     self							:			Tuple			):
				torch.manual_seed(0			)
				lowerCAmelCase_     :							List[Any]             =    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		,    )
				lowerCAmelCase_     :							int             =    PNDMScheduler(skip_prk_steps=a_			)
				torch.manual_seed(0			)
				lowerCAmelCase_     :							List[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			)
				lowerCAmelCase_     :							Dict             =    CLIPVisionConfig(
				    hidden_size=32		,    projection_dim=32		,    intermediate_size=37		,    layer_norm_eps=1e-0_5		,    num_attention_heads=4		,    num_hidden_layers=5		,    image_size=32		,    patch_size=4		,    )
				lowerCAmelCase_     :							List[Any]             =    CLIPVisionModelWithProjection(a_			)
				lowerCAmelCase_     :							Union[str, Any]             =    CLIPImageProcessor(crop_size=32		,    size=32			)

				lowerCAmelCase_     :							List[Any]             =    {
				    "unet": unet,
				    "scheduler": scheduler,
				    "vae": vae,
				    "image_encoder": image_encoder,
				    "feature_extractor": feature_extractor,
				    "safety_checker": None,
				}
				return components





		def      lowerCamelCase (     self							:			Optional[int]		,    a_							:			Tuple		,    a_							:			str=0			):
				lowerCAmelCase_     :							List[Any]             =    floats_tensor((1, 3, 32, 32)		,    rng=random.Random(a_			)			)
				lowerCAmelCase_     :							int             =    image.cpu().permute(0		,    2		,    3		,    1			)[0]
				lowerCAmelCase_     :							List[str]             =    Image.fromarray(np.uinta(a_			)			).convert("RGB"			).resize((32, 32)			)
				if str(a_			).startswith("mps"			):
						lowerCAmelCase_     :							Optional[int]             =    torch.manual_seed(a_			)
				else:
						lowerCAmelCase_     :							Optional[Any]             =    torch.Generator(device=a_			).manual_seed(a_			)
				lowerCAmelCase_     :							str             =    {
				    "image": image,
				    "generator": generator,
				    "num_inference_steps": 2,
				    "guidance_scale": 6.0,
				    "output_type": "numpy",
				}
				return inputs





		def      lowerCamelCase (     self							:			Any			):
				lowerCAmelCase_     :							int             =    "cpu"  # ensure determinism for the device-dependent torch.Generator
				lowerCAmelCase_     :							Dict             =    self.get_dummy_components()
				lowerCAmelCase_     :							Union[str, Any]             =    StableDiffusionImageVariationPipeline(**a_			)
				lowerCAmelCase_     :							int             =    sd_pipe.to(a_			)
				sd_pipe.set_progress_bar_config(disable=a_			)

				lowerCAmelCase_     :							Tuple             =    self.get_dummy_inputs(a_			)
				lowerCAmelCase_     :							List[str]             =    sd_pipe(**a_			).images
				lowerCAmelCase_     :							List[Any]             =    image[0, -3:, -3:, -1]

				assert image.shape == (1, 64, 64, 3)
				lowerCAmelCase_     :							List[str]             =    np.array([0.5239, 0.5723, 0.4796, 0.5049, 0.5550, 0.4685, 0.5329, 0.4891, 0.4921]			)

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





		def      lowerCamelCase (     self							:			Union[str, Any]			):
				lowerCAmelCase_     :							int             =    "cpu"  # ensure determinism for the device-dependent torch.Generator
				lowerCAmelCase_     :							Optional[Any]             =    self.get_dummy_components()
				lowerCAmelCase_     :							Tuple             =    StableDiffusionImageVariationPipeline(**a_			)
				lowerCAmelCase_     :							List[str]             =    sd_pipe.to(a_			)
				sd_pipe.set_progress_bar_config(disable=a_			)

				lowerCAmelCase_     :							List[str]             =    self.get_dummy_inputs(a_			)
				lowerCAmelCase_     :							Optional[Any]             =    2 * [inputs["image"]]
				lowerCAmelCase_     :							Optional[Any]             =    sd_pipe(**a_			)

				lowerCAmelCase_     :							Union[str, Any]             =    output.images

				lowerCAmelCase_     :							Optional[Any]             =    image[-1, -3:, -3:, -1]

				assert image.shape == (2, 64, 64, 3)
				lowerCAmelCase_     :							int             =    np.array([0.6892, 0.5637, 0.5836, 0.5771, 0.6254, 0.6409, 0.5580, 0.5569, 0.5289]			)

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





		def      lowerCamelCase (     self							:			str			):
				super().test_inference_batch_single_identical(expected_max_diff=3e-3			)







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





		'''simple docstring'''






		def      lowerCamelCase (     self							:			int			):
				super().tearDown()
				gc.collect()
				torch.cuda.empty_cache()





		def      lowerCamelCase (     self							:			Optional[Any]		,    a_							:			Optional[Any]		,    a_							:			List[str]="cpu"		,    a_							:			Optional[Any]=torch.floataa		,    a_							:			Optional[int]=0			):
				lowerCAmelCase_     :							str             =    torch.Generator(device=a_			).manual_seed(a_			)
				lowerCAmelCase_     :							str             =    load_image(
				    "https://huggingface.co/datasets/diffusers/test-arrays/resolve/main"
				    "/stable_diffusion_imgvar/input_image_vermeer.png"			)
				lowerCAmelCase_     :							Optional[Any]             =    np.random.RandomState(a_			).standard_normal((1, 4, 64, 64)			)
				lowerCAmelCase_     :							List[Any]             =    torch.from_numpy(a_			).to(device=a_		,    dtype=a_			)
				lowerCAmelCase_     :							Any             =    {
				    "image": init_image,
				    "latents": latents,
				    "generator": generator,
				    "num_inference_steps": 3,
				    "guidance_scale": 7.5,
				    "output_type": "numpy",
				}
				return inputs





		def      lowerCamelCase (     self							:			Any			):
				lowerCAmelCase_     :							Tuple             =    StableDiffusionImageVariationPipeline.from_pretrained(
				    "lambdalabs/sd-image-variations-diffusers"		,    safety_checker=a_			)
				lowerCAmelCase_     :							int             =    sd_pipe.to(a_			)
				sd_pipe.set_progress_bar_config(disable=a_			)

				lowerCAmelCase_     :							Union[str, Any]             =    self.get_inputs(a_			)
				lowerCAmelCase_     :							Union[str, Any]             =    sd_pipe(**a_			).images
				lowerCAmelCase_     :							Optional[int]             =    image[0, -3:, -3:, -1].flatten()

				assert image.shape == (1, 5_12, 5_12, 3)
				lowerCAmelCase_     :							Optional[Any]             =    np.array([0.84491, 0.90789, 0.75708, 0.78734, 0.83485, 0.70099, 0.66938, 0.68727, 0.61379]			)
				assert np.abs(image_slice - expected_slice			).max() < 6e-3





		def      lowerCamelCase (     self							:			Dict			):
				lowerCAmelCase_     :							List[str]             =    0

				def callback_fn(a_							:			int		,    a_							:			int		,    a_							:			torch.FloatTensor			) -> None:
						lowerCAmelCase_     :							str             =    True
						nonlocal number_of_steps
						number_of_steps += 1
						if step == 1:
								lowerCAmelCase_     :							str             =    latents.detach().cpu().numpy()
								assert latents.shape == (1, 4, 64, 64)
								lowerCAmelCase_     :							Dict             =    latents[0, -3:, -3:, -1]
								lowerCAmelCase_     :							List[Any]             =    np.array(
								    [-0.1621, 0.2837, -0.7979, -0.1221, -1.3057, 0.7681, -2.1191, 0.0464, 1.6309]			)

								assert np.abs(latents_slice.flatten() - expected_slice			).max() < 5e-2
						elif step == 2:
								lowerCAmelCase_     :							Dict             =    latents.detach().cpu().numpy()
								assert latents.shape == (1, 4, 64, 64)
								lowerCAmelCase_     :							Tuple             =    latents[0, -3:, -3:, -1]
								lowerCAmelCase_     :							Dict             =    np.array([0.6299, 1.7500, 1.1992, -2.1582, -1.8994, 0.7334, -0.7090, 1.0137, 1.5273]			)

								assert np.abs(latents_slice.flatten() - expected_slice			).max() < 5e-2

				lowerCAmelCase_     :							Union[str, Any]             =    False

				lowerCAmelCase_     :							str             =    StableDiffusionImageVariationPipeline.from_pretrained(
				    "fusing/sd-image-variations-diffusers"		,    safety_checker=a_		,    torch_dtype=torch.floataa		,    )
				pipe.to(a_			)
				pipe.set_progress_bar_config(disable=a_			)
				pipe.enable_attention_slicing()

				lowerCAmelCase_     :							Tuple             =    self.get_inputs(a_		,    dtype=torch.floataa			)
				pipe(**a_		,    callback=a_		,    callback_steps=1			)
				assert callback_fn.has_been_called
				assert number_of_steps == inputs["num_inference_steps"]





		def      lowerCamelCase (     self							:			Optional[Any]			):
				torch.cuda.empty_cache()
				torch.cuda.reset_max_memory_allocated()
				torch.cuda.reset_peak_memory_stats()

				lowerCAmelCase_     :							Tuple             =    "fusing/sd-image-variations-diffusers"
				lowerCAmelCase_     :							str             =    StableDiffusionImageVariationPipeline.from_pretrained(
				    a_		,    safety_checker=a_		,    torch_dtype=torch.floataa			)
				lowerCAmelCase_     :							int             =    pipe.to(a_			)
				pipe.set_progress_bar_config(disable=a_			)
				pipe.enable_attention_slicing(1			)
				pipe.enable_sequential_cpu_offload()

				lowerCAmelCase_     :							List[str]             =    self.get_inputs(a_		,    dtype=torch.floataa			)
				lowerCAmelCase_     :							Any             =    pipe(**a_			)

				lowerCAmelCase_     :							List[Any]             =    torch.cuda.max_memory_allocated()
				# make sure that less than 2.6 GB is allocated
				assert mem_bytes < 2.6 * 10**9







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





		'''simple docstring'''






		def      lowerCamelCase (     self							:			Tuple			):
				super().tearDown()
				gc.collect()
				torch.cuda.empty_cache()





		def      lowerCamelCase (     self							:			Optional[int]		,    a_							:			int		,    a_							:			int="cpu"		,    a_							:			str=torch.floataa		,    a_							:			Optional[Any]=0			):
				lowerCAmelCase_     :							str             =    torch.Generator(device=a_			).manual_seed(a_			)
				lowerCAmelCase_     :							int             =    load_image(
				    "https://huggingface.co/datasets/diffusers/test-arrays/resolve/main"
				    "/stable_diffusion_imgvar/input_image_vermeer.png"			)
				lowerCAmelCase_     :							Optional[Any]             =    np.random.RandomState(a_			).standard_normal((1, 4, 64, 64)			)
				lowerCAmelCase_     :							Optional[int]             =    torch.from_numpy(a_			).to(device=a_		,    dtype=a_			)
				lowerCAmelCase_     :							Union[str, Any]             =    {
				    "image": init_image,
				    "latents": latents,
				    "generator": generator,
				    "num_inference_steps": 50,
				    "guidance_scale": 7.5,
				    "output_type": "numpy",
				}
				return inputs





		def      lowerCamelCase (     self							:			Optional[int]			):
				lowerCAmelCase_     :							Any             =    StableDiffusionImageVariationPipeline.from_pretrained("fusing/sd-image-variations-diffusers"			)
				sd_pipe.to(a_			)
				sd_pipe.set_progress_bar_config(disable=a_			)

				lowerCAmelCase_     :							List[str]             =    self.get_inputs(a_			)
				lowerCAmelCase_     :							int             =    sd_pipe(**a_			).images[0]

				lowerCAmelCase_     :							Optional[Any]             =    load_numpy(
				    "https://huggingface.co/datasets/diffusers/test-arrays/resolve/main"
				    "/stable_diffusion_imgvar/lambdalabs_variations_pndm.npy"			)
				lowerCAmelCase_     :							List[Any]             =    np.abs(expected_image - image			).max()
				assert max_diff < 1e-3





		def      lowerCamelCase (     self							:			Any			):
				lowerCAmelCase_     :							List[Any]             =    StableDiffusionImageVariationPipeline.from_pretrained("fusing/sd-image-variations-diffusers"			)
				lowerCAmelCase_     :							Tuple             =    DPMSolverMultistepScheduler.from_config(sd_pipe.scheduler.config			)
				sd_pipe.to(a_			)
				sd_pipe.set_progress_bar_config(disable=a_			)

				lowerCAmelCase_     :							Optional[int]             =    self.get_inputs(a_			)
				lowerCAmelCase_     :							Tuple             =    25
				lowerCAmelCase_     :							int             =    sd_pipe(**a_			).images[0]

				lowerCAmelCase_     :							Union[str, Any]             =    load_numpy(
				    "https://huggingface.co/datasets/diffusers/test-arrays/resolve/main"
				    "/stable_diffusion_imgvar/lambdalabs_variations_dpm_multi.npy"			)
				lowerCAmelCase_     :							Optional[Any]             =    np.abs(expected_image - image			).max()
				assert max_diff < 1e-3
