
'''simple docstring'''






import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    EulerAncestralDiscreteScheduler,
    LMSDiscreteScheduler,
    PNDMScheduler,
    StableDiffusionPanoramaPipeline,
    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 PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()

@skip_mps
class 			UpperCAmelCase__    (							A    ,						A    ,						unittest.TestCase			):
    lowerCAmelCase_					     =		StableDiffusionPanoramaPipeline
    lowerCAmelCase_					     =		TEXT_TO_IMAGE_PARAMS
    lowerCAmelCase_					     =		TEXT_TO_IMAGE_BATCH_PARAMS
    lowerCAmelCase_					     =		TEXT_TO_IMAGE_IMAGE_PARAMS
    lowerCAmelCase_					     =		TEXT_TO_IMAGE_IMAGE_PARAMS



    def 	lowerCamelCase_	(						self   :							Tuple  ):
          torch.manual_seed(0  )
          _lowerCamelCase					: Optional[Any]		    = UNetaDConditionModel(
              block_out_channels=(3_2, 6_4),layers_per_block=1,sample_size=3_2,in_channels=4,out_channels=4,down_block_types=("DownBlock2D", "CrossAttnDownBlock2D"),up_block_types=("CrossAttnUpBlock2D", "UpBlock2D"),cross_attention_dim=3_2,)
          _lowerCamelCase					: List[Any]		    = DDIMScheduler()
          torch.manual_seed(0  )
          _lowerCamelCase					: Dict		    = AutoencoderKL(
              block_out_channels=[3_2, 6_4],in_channels=3,out_channels=3,down_block_types=["DownEncoderBlock2D", "DownEncoderBlock2D"],up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D"],latent_channels=4,)
          torch.manual_seed(0  )
          _lowerCamelCase					: List[Any]		    = CLIPTextConfig(
              bos_token_id=0,eos_token_id=2,hidden_size=3_2,intermediate_size=3_7,layer_norm_eps=1e-05,num_attention_heads=4,num_hidden_layers=5,pad_token_id=1,vocab_size=1_0_0_0,)
          _lowerCamelCase					: Tuple		    = CLIPTextModel(__A  )
          _lowerCamelCase					: Tuple		    = CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"  )

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



    def 	lowerCamelCase_	(						self   :							Optional[int],__A   :							Any,__A   :							Optional[int]=0  ):
          _lowerCamelCase					: Tuple		    = torch.manual_seed(__A  )
          _lowerCamelCase					: Any		    = {
              "prompt": "a photo of the dolomites",
              "generator": generator,
              # Setting height and width to None to prevent OOMs on CPU.
              "height": None,
              "width": None,
              "num_inference_steps": 1,
              "guidance_scale": 6.0,
              "output_type": "numpy",
          }
          return inputs



    def 	lowerCamelCase_	(						self   :							Any  ):
          _lowerCamelCase					: Tuple		    = "cpu"  # ensure determinism for the device-dependent torch.Generator
          _lowerCamelCase					: Optional[int]		    = self.get_dummy_components()
          _lowerCamelCase					: str		    = StableDiffusionPanoramaPipeline(**__A  )
          _lowerCamelCase					: List[str]		    = sd_pipe.to(__A  )
          sd_pipe.set_progress_bar_config(disable=__A  )

          _lowerCamelCase					: Dict		    = self.get_dummy_inputs(__A  )
          _lowerCamelCase					: Tuple		    = sd_pipe(**__A  ).images
          _lowerCamelCase					: int		    = image[0, -3:, -3:, -1]
          assert image.shape == (1, 6_4, 6_4, 3)

          _lowerCamelCase					: Tuple		    = np.array([0.6186, 0.5374, 0.4915, 0.4135, 0.4114, 0.4563, 0.5128, 0.4977, 0.4757]  )

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



    def 	lowerCamelCase_	(						self   :							int  ):
          super().test_inference_batch_consistent(batch_sizes=[1, 2]  )



    def 	lowerCamelCase_	(						self   :							Tuple  ):
          super().test_inference_batch_single_identical(batch_size=2,expected_max_diff=3.25e-3  )



    def 	lowerCamelCase_	(						self   :							str  ):
          _lowerCamelCase					: Union[str, Any]		    = "cpu"  # ensure determinism for the device-dependent torch.Generator
          _lowerCamelCase					: Tuple		    = self.get_dummy_components()
          _lowerCamelCase					: int		    = StableDiffusionPanoramaPipeline(**__A  )
          _lowerCamelCase					: Union[str, Any]		    = sd_pipe.to(__A  )
          sd_pipe.set_progress_bar_config(disable=__A  )

          _lowerCamelCase					: Any		    = self.get_dummy_inputs(__A  )
          _lowerCamelCase					: Tuple		    = "french fries"
          _lowerCamelCase					: Tuple		    = sd_pipe(**__A,negative_prompt=__A  )
          _lowerCamelCase					: Dict		    = output.images
          _lowerCamelCase					: List[str]		    = image[0, -3:, -3:, -1]

          assert image.shape == (1, 6_4, 6_4, 3)

          _lowerCamelCase					: Union[str, Any]		    = np.array([0.6187, 0.5375, 0.4915, 0.4136, 0.4114, 0.4563, 0.5128, 0.4976, 0.4757]  )

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



    def 	lowerCamelCase_	(						self   :							Dict  ):
          _lowerCamelCase					: Optional[Any]		    = "cpu"  # ensure determinism for the device-dependent torch.Generator
          _lowerCamelCase					: Optional[Any]		    = self.get_dummy_components()
          _lowerCamelCase					: Union[str, Any]		    = StableDiffusionPanoramaPipeline(**__A  )
          _lowerCamelCase					: int		    = sd_pipe.to(__A  )
          sd_pipe.set_progress_bar_config(disable=__A  )

          _lowerCamelCase					: Any		    = self.get_dummy_inputs(__A  )
          _lowerCamelCase					: Any		    = sd_pipe(**__A,view_batch_size=2  )
          _lowerCamelCase					: Tuple		    = output.images
          _lowerCamelCase					: Optional[int]		    = image[0, -3:, -3:, -1]

          assert image.shape == (1, 6_4, 6_4, 3)

          _lowerCamelCase					: List[Any]		    = np.array([0.6187, 0.5375, 0.4915, 0.4136, 0.4114, 0.4563, 0.5128, 0.4976, 0.4757]  )

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



    def 	lowerCamelCase_	(						self   :							Optional[Any]  ):
          _lowerCamelCase					: int		    = "cpu"  # ensure determinism for the device-dependent torch.Generator
          _lowerCamelCase					: List[Any]		    = self.get_dummy_components()
          _lowerCamelCase					: Optional[int]		    = EulerAncestralDiscreteScheduler(
              beta_start=0.00085,beta_end=0.012,beta_schedule="scaled_linear"  )
          _lowerCamelCase					: Any		    = StableDiffusionPanoramaPipeline(**__A  )
          _lowerCamelCase					: Any		    = sd_pipe.to(__A  )
          sd_pipe.set_progress_bar_config(disable=__A  )

          _lowerCamelCase					: Any		    = self.get_dummy_inputs(__A  )
          _lowerCamelCase					: Union[str, Any]		    = sd_pipe(**__A  ).images
          _lowerCamelCase					: List[str]		    = image[0, -3:, -3:, -1]

          assert image.shape == (1, 6_4, 6_4, 3)

          _lowerCamelCase					: str		    = np.array([0.4024, 0.6510, 0.4901, 0.5378, 0.5813, 0.5622, 0.4795, 0.4467, 0.4952]  )

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



    def 	lowerCamelCase_	(						self   :							Optional[Any]  ):
          _lowerCamelCase					: Union[str, Any]		    = "cpu"  # ensure determinism for the device-dependent torch.Generator
          _lowerCamelCase					: Dict		    = self.get_dummy_components()
          _lowerCamelCase					: Optional[int]		    = PNDMScheduler(
              beta_start=0.00085,beta_end=0.012,beta_schedule="scaled_linear",skip_prk_steps=__A  )
          _lowerCamelCase					: Union[str, Any]		    = StableDiffusionPanoramaPipeline(**__A  )
          _lowerCamelCase					: List[Any]		    = sd_pipe.to(__A  )
          sd_pipe.set_progress_bar_config(disable=__A  )

          _lowerCamelCase					: Tuple		    = self.get_dummy_inputs(__A  )
          _lowerCamelCase					: Dict		    = sd_pipe(**__A  ).images
          _lowerCamelCase					: Union[str, Any]		    = image[0, -3:, -3:, -1]

          assert image.shape == (1, 6_4, 6_4, 3)

          _lowerCamelCase					: List[Any]		    = np.array([0.6391, 0.6291, 0.4861, 0.5134, 0.5552, 0.4578, 0.5032, 0.5023, 0.4539]  )

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


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



    def 	lowerCamelCase_	(						self   :							Optional[int]  ):
          super().tearDown()
          gc.collect()
          torch.cuda.empty_cache()



    def 	lowerCamelCase_	(						self   :							List[str],__A   :							Dict=0  ):
          _lowerCamelCase					: List[Any]		    = torch.manual_seed(__A  )
          _lowerCamelCase					: Union[str, Any]		    = {
              "prompt": "a photo of the dolomites",
              "generator": generator,
              "num_inference_steps": 3,
              "guidance_scale": 7.5,
              "output_type": "numpy",
          }
          return inputs



    def 	lowerCamelCase_	(						self   :							List[Any]  ):
          _lowerCamelCase					: List[str]		    = "stabilityai/stable-diffusion-2-base"
          _lowerCamelCase					: Any		    = DDIMScheduler.from_pretrained(__A,subfolder="scheduler"  )
          _lowerCamelCase					: Tuple		    = StableDiffusionPanoramaPipeline.from_pretrained(__A,scheduler=__A,safety_checker=__A  )
          pipe.to(__A  )
          pipe.set_progress_bar_config(disable=__A  )
          pipe.enable_attention_slicing()

          _lowerCamelCase					: str		    = self.get_inputs()
          _lowerCamelCase					: int		    = pipe(**__A  ).images
          _lowerCamelCase					: Optional[int]		    = image[0, -3:, -3:, -1].flatten()

          assert image.shape == (1, 5_1_2, 2_0_4_8, 3)

          _lowerCamelCase					: List[Any]		    = np.array(
              [
                  0.36968392,
                  0.27025372,
                  0.32446766,
                  0.28379387,
                  0.36363274,
                  0.30733347,
                  0.27100027,
                  0.27054125,
                  0.25536096,
              ]  )

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



    def 	lowerCamelCase_	(						self   :							Any  ):
          _lowerCamelCase					: Optional[Any]		    = StableDiffusionPanoramaPipeline.from_pretrained(
              "stabilityai/stable-diffusion-2-base",safety_checker=__A  )
          _lowerCamelCase					: Union[str, Any]		    = LMSDiscreteScheduler.from_config(pipe.scheduler.config  )
          pipe.to(__A  )
          pipe.set_progress_bar_config(disable=__A  )
          pipe.enable_attention_slicing()

          _lowerCamelCase					: List[Any]		    = self.get_inputs()
          _lowerCamelCase					: Tuple		    = pipe(**__A  ).images
          _lowerCamelCase					: List[Any]		    = image[0, -3:, -3:, -1].flatten()

          assert image.shape == (1, 5_1_2, 2_0_4_8, 3)

          _lowerCamelCase					: List[Any]		    = np.array(
              [
                  [
                      0.0,
                      0.0,
                      0.0,
                      0.0,
                      0.0,
                      0.0,
                      0.0,
                      0.0,
                      0.0,
                  ]
              ]  )

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



    def 	lowerCamelCase_	(						self   :							str  ):
          _lowerCamelCase					: Any		    = 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					: int		    = latents.detach().cpu().numpy()
                      assert latents.shape == (1, 4, 6_4, 2_5_6)
                      _lowerCamelCase					: Dict		    = latents[0, -3:, -3:, -1]

                      _lowerCamelCase					: str		    = np.array(
                          [
                              0.18681869,
                              0.33907816,
                              0.5361276,
                              0.14432865,
                              -0.02856611,
                              -0.73941123,
                              0.23397987,
                              0.47322682,
                              -0.37823164,
                          ]  )
                      assert np.abs(latents_slice.flatten() - expected_slice  ).max() < 5e-2
                elif step == 2:
                      _lowerCamelCase					: Optional[int]		    = latents.detach().cpu().numpy()
                      assert latents.shape == (1, 4, 6_4, 2_5_6)
                      _lowerCamelCase					: Optional[int]		    = latents[0, -3:, -3:, -1]

                      _lowerCamelCase					: Tuple		    = np.array(
                          [
                              0.18539645,
                              0.33987248,
                              0.5378559,
                              0.14437142,
                              -0.02455261,
                              -0.7338317,
                              0.23990755,
                              0.47356272,
                              -0.3786505,
                          ]  )

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

          _lowerCamelCase					: List[str]		    = False

          _lowerCamelCase					: Optional[int]		    = "stabilityai/stable-diffusion-2-base"
          _lowerCamelCase					: Optional[Any]		    = DDIMScheduler.from_pretrained(__A,subfolder="scheduler"  )
          _lowerCamelCase					: Union[str, Any]		    = StableDiffusionPanoramaPipeline.from_pretrained(__A,scheduler=__A,safety_checker=__A  )
          _lowerCamelCase					: Union[str, Any]		    = pipe.to(__A  )
          pipe.set_progress_bar_config(disable=__A  )
          pipe.enable_attention_slicing()

          _lowerCamelCase					: int		    = self.get_inputs()
          pipe(**__A,callback=__A,callback_steps=1  )
          assert callback_fn.has_been_called
          assert number_of_steps == 3



    def 	lowerCamelCase_	(						self   :							Tuple  ):
          torch.cuda.empty_cache()
          torch.cuda.reset_max_memory_allocated()
          torch.cuda.reset_peak_memory_stats()

          _lowerCamelCase					: int		    = "stabilityai/stable-diffusion-2-base"
          _lowerCamelCase					: Tuple		    = DDIMScheduler.from_pretrained(__A,subfolder="scheduler"  )
          _lowerCamelCase					: List[Any]		    = StableDiffusionPanoramaPipeline.from_pretrained(__A,scheduler=__A,safety_checker=__A  )
          _lowerCamelCase					: Optional[Any]		    = pipe.to(__A  )
          pipe.set_progress_bar_config(disable=__A  )
          pipe.enable_attention_slicing(1  )
          pipe.enable_sequential_cpu_offload()

          _lowerCamelCase					: Optional[Any]		    = self.get_inputs()
          _lowerCamelCase					: str		    = pipe(**__A  )

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


import string





def    __lowerCamelCase      (					UpperCamelCase__ ):







							'''simple docstring'''






							snake_case_     							=       ''
							for i in sequence:
														snake_case_     							=       ord(UpperCamelCase__ )
														if 65 <= extract <= 90:
																					output += chr(155 - extract )
														elif 97 <= extract <= 122:
																					output += chr(219 - extract )
														else:
																					output += i
							return output





def    __lowerCamelCase      (					UpperCamelCase__ ):







							'''simple docstring'''






							snake_case_     							=       string.ascii_letters
							snake_case_     							=       string.ascii_lowercase[::-1] + string.ascii_uppercase[::-1]
							return "".join(
							    letters_reversed[letters.index(UpperCamelCase__ )] if c in letters else c for c in sequence )





def    __lowerCamelCase      (					):







							'''simple docstring'''






							from timeit import timeit

							print('Running performance benchmarks...' )
							snake_case_     							=       'from string import printable ; from __main__ import atbash, atbash_slow'
							print(F'''> atbash_slow(): {timeit("atbash_slow(printable)"  ,				setup=UpperCamelCase__ )} seconds''' )
							print(F'''>      atbash(): {timeit("atbash(printable)"  ,				setup=UpperCamelCase__ )} seconds''' )


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




