


"""simple docstring"""



import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    PNDMScheduler,
    StableDiffusionLDMaDPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import nightly, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS


enable_full_determinism()







class _lowerCAmelCase    (				unittest.TestCase     ):
   __UpperCAmelCase			:	int							  =  StableDiffusionLDMaDPipeline
   __UpperCAmelCase			:	List[str]							  =  TEXT_TO_IMAGE_PARAMS
   __UpperCAmelCase			:	str							  =  TEXT_TO_IMAGE_BATCH_PARAMS
   __UpperCAmelCase			:	Union[str, Any]							  =  TEXT_TO_IMAGE_IMAGE_PARAMS







   def 			lowerCamelCase		(     self						)     ->		int:

       '''simple docstring'''




       torch.manual_seed(0						)
       snake_case   :				Tuple				 =   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						,     )
       snake_case   :				str				 =   DDIMScheduler(
           beta_start=0.00085						,     beta_end=0.012						,     beta_schedule="scaled_linear"						,     clip_sample=__a						,     set_alpha_to_one=__a						,     )
       torch.manual_seed(0						)
       snake_case   :				Any				 =   AutoencoderKL(
           block_out_channels=[32, 64]						,     in_channels=6						,     out_channels=6						,     down_block_types=["DownEncoderBlock2D", "DownEncoderBlock2D"]						,     up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D"]						,     latent_channels=4						,     )
       torch.manual_seed(0						)
       snake_case   :				Dict				 =   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						,     )
       snake_case   :				str				 =   CLIPTextModel(__a						)
       snake_case   :				List[Any]				 =   CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"						)

       snake_case   :				Tuple				 =   {
           "unet": unet,
           "scheduler": scheduler,
           "vae": vae,
           "text_encoder": text_encoder,
           "tokenizer": tokenizer,
           "safety_checker": None,
           "feature_extractor": None,
       }
       return components







   def 			lowerCamelCase		(     self						,     UpperCamelCase__						,     UpperCamelCase__=0						)     ->		List[Any]:

       '''simple docstring'''




       if str(__a						).startswith("mps"						):
           snake_case   :				List[Any]				 =   torch.manual_seed(__a						)
       else:
           snake_case   :				Tuple				 =   torch.Generator(device=__a						).manual_seed(__a						)
       snake_case   :				int				 =   {
           "prompt": "A painting of a squirrel eating a burger",
           "generator": generator,
           "num_inference_steps": 2,
           "guidance_scale": 6.0,
           "output_type": "numpy",
       }
       return inputs







   def 			lowerCamelCase		(     self						)     ->		Dict:

       '''simple docstring'''




       snake_case   :				Optional[Any]				 =   "cpu"  # ensure determinism for the device-dependent torch.Generator

       snake_case   :				Optional[Any]				 =   self.get_dummy_components()
       snake_case   :				Dict				 =   StableDiffusionLDMaDPipeline(**__a						)
       snake_case   :				Tuple				 =   ldmad_pipe.to(__a						)
       ldmad_pipe.set_progress_bar_config(disable=__a						)

       snake_case   :				int				 =   self.get_dummy_inputs(__a						)
       snake_case   :				List[Any]				 =   ldmad_pipe(**__a						)
       snake_case ,snake_case   :				Optional[int]				 =   output.rgb, output.depth

       snake_case   :				Optional[Any]				 =   rgb[0, -3:, -3:, -1]
       snake_case   :				Tuple				 =   depth[0, -3:, -1]

       assert rgb.shape == (1, 64, 64, 3)
       assert depth.shape == (1, 64, 64)

       snake_case   :				Optional[Any]				 =   np.array(
           [0.37338176, 0.70247, 0.74203193, 0.51643604, 0.58256793, 0.60932136, 0.4181095, 0.48355877, 0.46535262]						)
       snake_case   :				Any				 =   np.array([103.46727, 85.812004, 87.849236]						)

       assert np.abs(image_slice_rgb.flatten() - expected_slice_rgb						).max() < 1e-2
       assert np.abs(image_slice_depth.flatten() - expected_slice_depth						).max() < 1e-2







   def 			lowerCamelCase		(     self						)     ->		Tuple:

       '''simple docstring'''




       snake_case   :				Any				 =   self.get_dummy_components()
       snake_case   :				int				 =   StableDiffusionLDMaDPipeline(**__a						)
       snake_case   :				Dict				 =   ldmad_pipe.to(__a						)
       ldmad_pipe.set_progress_bar_config(disable=__a						)

       snake_case   :				str				 =   self.get_dummy_inputs(__a						)
       snake_case   :				str				 =   3 * [inputs["prompt"]]

       # forward
       snake_case   :				Optional[Any]				 =   ldmad_pipe(**__a						)
       snake_case ,snake_case   :				List[Any]				 =   output.rgb, output.depth
       snake_case   :				str				 =   rgb_slice_a[0, -3:, -3:, -1]
       snake_case   :				List[str]				 =   depth_slice_a[0, -3:, -1]

       snake_case   :				Dict				 =   self.get_dummy_inputs(__a						)
       snake_case   :				Any				 =   3 * [inputs.pop("prompt"						)]

       snake_case   :				Union[str, Any]				 =   ldmad_pipe.tokenizer(
           __a						,     padding="max_length"						,     max_length=ldmad_pipe.tokenizer.model_max_length						,     truncation=__a						,     return_tensors="pt"						,     )
       snake_case   :				Dict				 =   text_inputs["input_ids"].to(__a						)

       snake_case   :				Optional[int]				 =   ldmad_pipe.text_encoder(__a						)[0]

       snake_case   :				List[str]				 =   prompt_embeds

       # forward
       snake_case   :				int				 =   ldmad_pipe(**__a						)
       snake_case ,snake_case   :				List[str]				 =   output.rgb, output.depth
       snake_case   :				List[str]				 =   rgb_slice_a[0, -3:, -3:, -1]
       snake_case   :				Optional[Any]				 =   depth_slice_a[0, -3:, -1]

       assert np.abs(rgb_slice_a.flatten() - rgb_slice_a.flatten()						).max() < 1e-4
       assert np.abs(depth_slice_a.flatten() - depth_slice_a.flatten()						).max() < 1e-4







   def 			lowerCamelCase		(     self						)     ->		str:

       '''simple docstring'''




       snake_case   :				List[str]				 =   "cpu"  # ensure determinism for the device-dependent torch.Generator
       snake_case   :				Union[str, Any]				 =   self.get_dummy_components()
       snake_case   :				Union[str, Any]				 =   PNDMScheduler(skip_prk_steps=__a						)
       snake_case   :				Union[str, Any]				 =   StableDiffusionLDMaDPipeline(**__a						)
       snake_case   :				str				 =   ldmad_pipe.to(__a						)
       ldmad_pipe.set_progress_bar_config(disable=__a						)

       snake_case   :				str				 =   self.get_dummy_inputs(__a						)
       snake_case   :				int				 =   "french fries"
       snake_case   :				Any				 =   ldmad_pipe(**__a						,     negative_prompt=__a						)

       snake_case ,snake_case   :				Optional[int]				 =   output.rgb, output.depth
       snake_case   :				Union[str, Any]				 =   rgb[0, -3:, -3:, -1]
       snake_case   :				List[str]				 =   depth[0, -3:, -1]

       assert rgb.shape == (1, 64, 64, 3)
       assert depth.shape == (1, 64, 64)

       snake_case   :				Union[str, Any]				 =   np.array(
           [0.37044, 0.71811503, 0.7223251, 0.48603675, 0.5638391, 0.6364948, 0.42833704, 0.4901315, 0.47926217]						)
       snake_case   :				Union[str, Any]				 =   np.array([107.84738, 84.62802, 89.962135]						)
       assert np.abs(rgb_slice.flatten() - expected_slice_rgb						).max() < 1e-2
       assert np.abs(depth_slice.flatten() - expected_slice_depth						).max() < 1e-2







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







   def 			lowerCamelCase		(     self						)     ->		List[str]:

       '''simple docstring'''




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







   def 			lowerCamelCase		(     self						,     UpperCamelCase__						,     UpperCamelCase__="cpu"						,     UpperCamelCase__=torch.floataa						,     UpperCamelCase__=0						)     ->		str:

       '''simple docstring'''




       snake_case   :				Dict				 =   torch.Generator(device=__a						).manual_seed(__a						)
       snake_case   :				Dict				 =   np.random.RandomState(__a						).standard_normal((1, 4, 64, 64)						)
       snake_case   :				Any				 =   torch.from_numpy(__a						).to(device=__a						,     dtype=__a						)
       snake_case   :				str				 =   {
           "prompt": "a photograph of an astronaut riding a horse",
           "latents": latents,
           "generator": generator,
           "num_inference_steps": 3,
           "guidance_scale": 7.5,
           "output_type": "numpy",
       }
       return inputs







   def 			lowerCamelCase		(     self						)     ->		int:

       '''simple docstring'''




       snake_case   :				Tuple				 =   StableDiffusionLDMaDPipeline.from_pretrained("Intel/ldm3d"						)
       snake_case   :				List[str]				 =   ldmad_pipe.to(__a						)
       ldmad_pipe.set_progress_bar_config(disable=__a						)

       snake_case   :				int				 =   self.get_inputs(__a						)
       snake_case   :				Optional[Any]				 =   ldmad_pipe(**__a						)
       snake_case ,snake_case   :				Dict				 =   output.rgb, output.depth
       snake_case   :				List[Any]				 =   rgb[0, -3:, -3:, -1].flatten()
       snake_case   :				Optional[int]				 =   rgb[0, -3:, -1].flatten()

       assert rgb.shape == (1, 512, 512, 3)
       assert depth.shape == (1, 512, 512)

       snake_case   :				Dict				 =   np.array(
           [0.53805465, 0.56707305, 0.5486515, 0.57012236, 0.5814511, 0.56253487, 0.54843014, 0.55092263, 0.6459706]						)
       snake_case   :				Dict				 =   np.array(
           [0.9263781, 0.6678672, 0.5486515, 0.92202145, 0.67831135, 0.56253487, 0.9241694, 0.7551478, 0.6459706]						)
       assert np.abs(rgb_slice - expected_slice_rgb						).max() < 3e-3
       assert np.abs(depth_slice - expected_slice_depth						).max() < 3e-3







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







   def 			lowerCamelCase		(     self						)     ->		str:

       '''simple docstring'''




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







   def 			lowerCamelCase		(     self						,     UpperCamelCase__						,     UpperCamelCase__="cpu"						,     UpperCamelCase__=torch.floataa						,     UpperCamelCase__=0						)     ->		List[Any]:

       '''simple docstring'''




       snake_case   :				Tuple				 =   torch.Generator(device=__a						).manual_seed(__a						)
       snake_case   :				List[Any]				 =   np.random.RandomState(__a						).standard_normal((1, 4, 64, 64)						)
       snake_case   :				List[str]				 =   torch.from_numpy(__a						).to(device=__a						,     dtype=__a						)
       snake_case   :				Optional[Any]				 =   {
           "prompt": "a photograph of an astronaut riding a horse",
           "latents": latents,
           "generator": generator,
           "num_inference_steps": 50,
           "guidance_scale": 7.5,
           "output_type": "numpy",
       }
       return inputs







   def 			lowerCamelCase		(     self						)     ->		Tuple:

       '''simple docstring'''




       snake_case   :				List[str]				 =   StableDiffusionLDMaDPipeline.from_pretrained("Intel/ldm3d"						).to(__a						)
       ldmad_pipe.set_progress_bar_config(disable=__a						)

       snake_case   :				List[Any]				 =   self.get_inputs(__a						)
       snake_case   :				Union[str, Any]				 =   ldmad_pipe(**__a						)
       snake_case ,snake_case   :				Tuple				 =   output.rgb, output.depth

       snake_case   :				List[str]				 =   0.495586
       snake_case   :				List[str]				 =   0.33795515
       snake_case   :				Dict				 =   112.48518
       snake_case   :				List[Any]				 =   98.489746
       assert np.abs(expected_rgb_mean - rgb.mean()						) < 1e-3
       assert np.abs(expected_rgb_std - rgb.std()						) < 1e-3
       assert np.abs(expected_depth_mean - depth.mean()						) < 1e-3
       assert np.abs(expected_depth_std - depth.std()						) < 1e-3







   def 			lowerCamelCase		(     self						)     ->		str:

       '''simple docstring'''




       snake_case   :				Any				 =   StableDiffusionLDMaDPipeline.from_pretrained("Intel/ldm3d-4c"						).to(__a						)
       ldmad_pipe.set_progress_bar_config(disable=__a						)

       snake_case   :				Optional[int]				 =   self.get_inputs(__a						)
       snake_case   :				Tuple				 =   ldmad_pipe(**__a						)
       snake_case ,snake_case   :				List[Any]				 =   output.rgb, output.depth

       snake_case   :				Tuple				 =   0.4194127
       snake_case   :				Optional[int]				 =   0.35375586
       snake_case   :				Dict				 =   0.5638502
       snake_case   :				int				 =   0.34686103

       assert rgb.shape == (1, 512, 512, 3)
       assert depth.shape == (1, 512, 512, 1)
       assert np.abs(expected_rgb_mean - rgb.mean()						) < 1e-3
       assert np.abs(expected_rgb_std - rgb.std()						) < 1e-3
       assert np.abs(expected_depth_mean - depth.mean()						) < 1e-3
       assert np.abs(expected_depth_std - depth.std()						) < 1e-3









"""simple docstring"""



import string







def   __lowerCAmelCase						(						lowercase  :  str			)     ->						str:


    """simple docstring"""





    snake_case   :				List[str]				 =   ""
    for i in sequence:
        snake_case   :				Optional[Any]				 =   ord(lowercase			)
        if 65 <= extract <= 90:
            output += chr(155 - extract			)
        elif 97 <= extract <= 122:
            output += chr(219 - extract			)
        else:
            output += i
    return output







def   __lowerCAmelCase						(						lowercase  :  str			)     ->						str:


    """simple docstring"""





    snake_case   :				Dict				 =   string.ascii_letters
    snake_case   :				List[Any]				 =   string.ascii_lowercase[::-1] + string.ascii_uppercase[::-1]
    return "".join(
        letters_reversed[letters.index(lowercase			)] if c in letters else c for c in sequence			)







def   __lowerCAmelCase						(						)     ->						None:


    """simple docstring"""





    from timeit import timeit

    print("Running performance benchmarks..."			)
    snake_case   :				Optional[int]				 =   "from string import printable ; from __main__ import atbash, atbash_slow"
    print(F'> atbash_slow(): {timeit("atbash_slow(printable)"						,							setup=lowercase			)} seconds'			)
    print(F'>      atbash(): {timeit("atbash(printable)"						,							setup=lowercase			)} seconds'			)


if __name__ == "__main__":
  for example in ("ABCDEFGH", "123GGjj", "testStringtest", "with space"):
    print(F'''{example} encrypted in atbash: {atbash(example)}''')
  benchmark()





