





'''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    lowerCAmelCase_		(		lowerCAmelCase__						,lowerCAmelCase__						,unittest.TestCase		):
 __lowerCamelCase						:							Tuple         =					StableDiffusionPanoramaPipeline
 __lowerCamelCase						:							List[Any]         =					TEXT_TO_IMAGE_PARAMS
 __lowerCamelCase						:							Optional[int]         =					TEXT_TO_IMAGE_BATCH_PARAMS
 __lowerCamelCase						:							Any         =					TEXT_TO_IMAGE_IMAGE_PARAMS
 __lowerCamelCase						:							Dict         =					TEXT_TO_IMAGE_IMAGE_PARAMS




 def 							_snake_case   (	self		)    ->							str:
     torch.manual_seed(0		)
     _lowerCAmelCase				=				UNetaDConditionModel(
         block_out_channels=(32, 64)			,     layers_per_block=1			,     sample_size=32			,     in_channels=4			,     out_channels=4			,     down_block_types=("DownBlock2D", "CrossAttnDownBlock2D")			,     up_block_types=("CrossAttnUpBlock2D", "UpBlock2D")			,     cross_attention_dim=32			,     )
     _lowerCAmelCase				=				DDIMScheduler()
     torch.manual_seed(0		)
     _lowerCAmelCase				=				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				=				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			,     )
     _lowerCAmelCase				=				CLIPTextModel(_SCREAMING_SNAKE_CASE		)
     _lowerCAmelCase				=				CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"		)

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




 def 							_snake_case   (	self			,     _lowerCAmelCase			,     _lowerCAmelCase=0		)    ->							Any:
     _lowerCAmelCase				=				torch.manual_seed(_SCREAMING_SNAKE_CASE		)
     _lowerCAmelCase				=				{
         "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 							_snake_case   (	self		)    ->							str:
     _lowerCAmelCase				=				"cpu"  # ensure determinism for the device-dependent torch.Generator
     _lowerCAmelCase				=				self.get_dummy_components()
     _lowerCAmelCase				=				StableDiffusionPanoramaPipeline(**_SCREAMING_SNAKE_CASE		)
     _lowerCAmelCase				=				sd_pipe.to(_SCREAMING_SNAKE_CASE		)
     sd_pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE		)

     _lowerCAmelCase				=				self.get_dummy_inputs(_SCREAMING_SNAKE_CASE		)
     _lowerCAmelCase				=				sd_pipe(**_SCREAMING_SNAKE_CASE		).images
     _lowerCAmelCase				=				image[0, -3:, -3:, -1]
     assert image.shape == (1, 64, 64, 3)

     _lowerCAmelCase				=				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 							_snake_case   (	self		)    ->							Dict:
     super().test_inference_batch_consistent(batch_sizes=[1, 2]		)




 def 							_snake_case   (	self		)    ->							Optional[Any]:
     super().test_inference_batch_single_identical(batch_size=2			,     expected_max_diff=3.25E-3		)




 def 							_snake_case   (	self		)    ->							List[str]:
     _lowerCAmelCase				=				"cpu"  # ensure determinism for the device-dependent torch.Generator
     _lowerCAmelCase				=				self.get_dummy_components()
     _lowerCAmelCase				=				StableDiffusionPanoramaPipeline(**_SCREAMING_SNAKE_CASE		)
     _lowerCAmelCase				=				sd_pipe.to(_SCREAMING_SNAKE_CASE		)
     sd_pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE		)

     _lowerCAmelCase				=				self.get_dummy_inputs(_SCREAMING_SNAKE_CASE		)
     _lowerCAmelCase				=				"french fries"
     _lowerCAmelCase				=				sd_pipe(**_SCREAMING_SNAKE_CASE			,     negative_prompt=_SCREAMING_SNAKE_CASE		)
     _lowerCAmelCase				=				output.images
     _lowerCAmelCase				=				image[0, -3:, -3:, -1]

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

     _lowerCAmelCase				=				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 							_snake_case   (	self		)    ->							Any:
     _lowerCAmelCase				=				"cpu"  # ensure determinism for the device-dependent torch.Generator
     _lowerCAmelCase				=				self.get_dummy_components()
     _lowerCAmelCase				=				StableDiffusionPanoramaPipeline(**_SCREAMING_SNAKE_CASE		)
     _lowerCAmelCase				=				sd_pipe.to(_SCREAMING_SNAKE_CASE		)
     sd_pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE		)

     _lowerCAmelCase				=				self.get_dummy_inputs(_SCREAMING_SNAKE_CASE		)
     _lowerCAmelCase				=				sd_pipe(**_SCREAMING_SNAKE_CASE			,     view_batch_size=2		)
     _lowerCAmelCase				=				output.images
     _lowerCAmelCase				=				image[0, -3:, -3:, -1]

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

     _lowerCAmelCase				=				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 							_snake_case   (	self		)    ->							Dict:
     _lowerCAmelCase				=				"cpu"  # ensure determinism for the device-dependent torch.Generator
     _lowerCAmelCase				=				self.get_dummy_components()
     _lowerCAmelCase				=				EulerAncestralDiscreteScheduler(
         beta_start=0.00085			,     beta_end=0.012			,     beta_schedule="scaled_linear"		)
     _lowerCAmelCase				=				StableDiffusionPanoramaPipeline(**_SCREAMING_SNAKE_CASE		)
     _lowerCAmelCase				=				sd_pipe.to(_SCREAMING_SNAKE_CASE		)
     sd_pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE		)

     _lowerCAmelCase				=				self.get_dummy_inputs(_SCREAMING_SNAKE_CASE		)
     _lowerCAmelCase				=				sd_pipe(**_SCREAMING_SNAKE_CASE		).images
     _lowerCAmelCase				=				image[0, -3:, -3:, -1]

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

     _lowerCAmelCase				=				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 							_snake_case   (	self		)    ->							str:
     _lowerCAmelCase				=				"cpu"  # ensure determinism for the device-dependent torch.Generator
     _lowerCAmelCase				=				self.get_dummy_components()
     _lowerCAmelCase				=				PNDMScheduler(
         beta_start=0.00085			,     beta_end=0.012			,     beta_schedule="scaled_linear"			,     skip_prk_steps=_SCREAMING_SNAKE_CASE		)
     _lowerCAmelCase				=				StableDiffusionPanoramaPipeline(**_SCREAMING_SNAKE_CASE		)
     _lowerCAmelCase				=				sd_pipe.to(_SCREAMING_SNAKE_CASE		)
     sd_pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE		)

     _lowerCAmelCase				=				self.get_dummy_inputs(_SCREAMING_SNAKE_CASE		)
     _lowerCAmelCase				=				sd_pipe(**_SCREAMING_SNAKE_CASE		).images
     _lowerCAmelCase				=				image[0, -3:, -3:, -1]

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

     _lowerCAmelCase				=				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    lowerCAmelCase_		(		unittest.TestCase		):




 def 							_snake_case   (	self		)    ->							List[Any]:
     super().tearDown()
     gc.collect()
     torch.cuda.empty_cache()




 def 							_snake_case   (	self			,     _lowerCAmelCase=0		)    ->							List[str]:
     _lowerCAmelCase				=				torch.manual_seed(_SCREAMING_SNAKE_CASE		)
     _lowerCAmelCase				=				{
         "prompt": "a photo of the dolomites",
         "generator": generator,
         "num_inference_steps": 3,
         "guidance_scale": 7.5,
         "output_type": "numpy",
     }
     return inputs




 def 							_snake_case   (	self		)    ->							Union[str, Any]:
     _lowerCAmelCase				=				"stabilityai/stable-diffusion-2-base"
     _lowerCAmelCase				=				DDIMScheduler.from_pretrained(_SCREAMING_SNAKE_CASE			,     subfolder="scheduler"		)
     _lowerCAmelCase				=				StableDiffusionPanoramaPipeline.from_pretrained(_SCREAMING_SNAKE_CASE			,     scheduler=_SCREAMING_SNAKE_CASE			,     safety_checker=_SCREAMING_SNAKE_CASE		)
     pipe.to(_SCREAMING_SNAKE_CASE		)
     pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE		)
     pipe.enable_attention_slicing()

     _lowerCAmelCase				=				self.get_inputs()
     _lowerCAmelCase				=				pipe(**_SCREAMING_SNAKE_CASE		).images
     _lowerCAmelCase				=				image[0, -3:, -3:, -1].flatten()

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

     _lowerCAmelCase				=				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 							_snake_case   (	self		)    ->							Any:
     _lowerCAmelCase				=				StableDiffusionPanoramaPipeline.from_pretrained(
         "stabilityai/stable-diffusion-2-base"			,     safety_checker=_SCREAMING_SNAKE_CASE		)
     _lowerCAmelCase				=				LMSDiscreteScheduler.from_config(pipe.scheduler.config		)
     pipe.to(_SCREAMING_SNAKE_CASE		)
     pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE		)
     pipe.enable_attention_slicing()

     _lowerCAmelCase				=				self.get_inputs()
     _lowerCAmelCase				=				pipe(**_SCREAMING_SNAKE_CASE		).images
     _lowerCAmelCase				=				image[0, -3:, -3:, -1].flatten()

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

     _lowerCAmelCase				=				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 							_snake_case   (	self		)    ->							Union[str, Any]:
     _lowerCAmelCase				=				0

     def callback_fn(_lowerCAmelCase			,     _lowerCAmelCase			,     _lowerCAmelCase		) -> None:
         _lowerCAmelCase				=				True
         nonlocal number_of_steps
         number_of_steps += 1
         if step == 1:
             _lowerCAmelCase				=				latents.detach().cpu().numpy()
             assert latents.shape == (1, 4, 64, 256)
             _lowerCAmelCase				=				latents[0, -3:, -3:, -1]

             _lowerCAmelCase				=				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				=				latents.detach().cpu().numpy()
             assert latents.shape == (1, 4, 64, 256)
             _lowerCAmelCase				=				latents[0, -3:, -3:, -1]

             _lowerCAmelCase				=				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				=				False

     _lowerCAmelCase				=				"stabilityai/stable-diffusion-2-base"
     _lowerCAmelCase				=				DDIMScheduler.from_pretrained(_SCREAMING_SNAKE_CASE			,     subfolder="scheduler"		)
     _lowerCAmelCase				=				StableDiffusionPanoramaPipeline.from_pretrained(_SCREAMING_SNAKE_CASE			,     scheduler=_SCREAMING_SNAKE_CASE			,     safety_checker=_SCREAMING_SNAKE_CASE		)
     _lowerCAmelCase				=				pipe.to(_SCREAMING_SNAKE_CASE		)
     pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE		)
     pipe.enable_attention_slicing()

     _lowerCAmelCase				=				self.get_inputs()
     pipe(**_SCREAMING_SNAKE_CASE			,     callback=_SCREAMING_SNAKE_CASE			,     callback_steps=1		)
     assert callback_fn.has_been_called
     assert number_of_steps == 3





 def 							_snake_case   (	self		)    ->							Tuple:
     torch.cuda.empty_cache()
     torch.cuda.reset_max_memory_allocated()
     torch.cuda.reset_peak_memory_stats()

     _lowerCAmelCase				=				"stabilityai/stable-diffusion-2-base"
     _lowerCAmelCase				=				DDIMScheduler.from_pretrained(_SCREAMING_SNAKE_CASE			,     subfolder="scheduler"		)
     _lowerCAmelCase				=				StableDiffusionPanoramaPipeline.from_pretrained(_SCREAMING_SNAKE_CASE			,     scheduler=_SCREAMING_SNAKE_CASE			,     safety_checker=_SCREAMING_SNAKE_CASE		)
     _lowerCAmelCase				=				pipe.to(_SCREAMING_SNAKE_CASE		)
     pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE		)
     pipe.enable_attention_slicing(1		)
     pipe.enable_sequential_cpu_offload()

     _lowerCAmelCase				=				self.get_inputs()
     _lowerCAmelCase				=				pipe(**_SCREAMING_SNAKE_CASE		)

     _lowerCAmelCase				=				torch.cuda.max_memory_allocated()
     # make sure that less than 5.2 GB is allocated
     assert mem_bytes < 5.5 * 10**9









'''simple docstring'''


def 	__a(SCREAMING_SNAKE_CASE_  :					int    ):



    '''simple docstring'''





    if not isinstance(SCREAMING_SNAKE_CASE_		,       SCREAMING_SNAKE_CASE_    ):
        raise ValueError("check_bouncy() accepts only integer arguments"    )
    _lowerCAmelCase				=      str(SCREAMING_SNAKE_CASE_    )
    _lowerCAmelCase				=      "".join(sorted(SCREAMING_SNAKE_CASE_    )    )
    return sorted_str_n != str_n and sorted_str_n[::-1] != str_n


def 	__a(SCREAMING_SNAKE_CASE_  :					float = 99    ):



    '''simple docstring'''





    if not 0 < percent < 100:
        raise ValueError("solution() only accepts values from 0 to 100"    )
    _lowerCAmelCase				=      0
    _lowerCAmelCase				=      1

    while True:
        if check_bouncy(SCREAMING_SNAKE_CASE_    ):
            bouncy_num += 1
        if (bouncy_num / num) * 100 >= percent:
            return num
        num += 1


if __name__ == "__main__":
       from doctest import testmod

       testmod()
       print(f'''{solution(99)}''')


