




"""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   a__			(       __lowerCamelCase					,	__lowerCamelCase					,	unittest.TestCase  ):
						snake_case__             = StableDiffusionPanoramaPipeline
						snake_case__             = TEXT_TO_IMAGE_PARAMS
						snake_case__             = TEXT_TO_IMAGE_BATCH_PARAMS
						snake_case__             = TEXT_TO_IMAGE_IMAGE_PARAMS
						snake_case__             = TEXT_TO_IMAGE_IMAGE_PARAMS





						def       __UpperCamelCase     (							self      :	Dict)						->       Optional[Any]:




											"""simple docstring"""







											torch.manual_seed(0)
											_lowerCAmelCase:Any									=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:Optional[Any]									=DDIMScheduler()
											torch.manual_seed(0)
											_lowerCAmelCase:List[str]									=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:Optional[int]									=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:Optional[int]									=CLIPTextModel(SCREAMING_SNAKE_CASE_)
											_lowerCAmelCase:Any									=CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip''')

											_lowerCAmelCase: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      :	Optional[Any]     ,a__      :	str     ,a__      :	List[str]=0)						->       Dict:




											"""simple docstring"""







											_lowerCAmelCase:str									=torch.manual_seed(SCREAMING_SNAKE_CASE_)
											_lowerCAmelCase:int									={
											    '''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       __UpperCamelCase     (							self      :	Optional[Any])						->       str:




											"""simple docstring"""







											_lowerCAmelCase:Optional[int]									='''cpu'''  # ensure determinism for the device-dependent torch.Generator
											_lowerCAmelCase:Dict									=self.get_dummy_components()
											_lowerCAmelCase:List[Any]									=StableDiffusionPanoramaPipeline(**SCREAMING_SNAKE_CASE_)
											_lowerCAmelCase:List[Any]									=sd_pipe.to(SCREAMING_SNAKE_CASE_)
											sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_)

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

											_lowerCAmelCase:Any									=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       __UpperCamelCase     (							self      :	Any)						->       Any:




											"""simple docstring"""







											super().test_inference_batch_consistent(batch_sizes=[1, 2])





						def       __UpperCamelCase     (							self      :	int)						->       Dict:




											"""simple docstring"""







											super().test_inference_batch_single_identical(batch_size=2     ,expected_max_diff=3.25E-3)





						def       __UpperCamelCase     (							self      :	Union[str, Any])						->       List[str]:




											"""simple docstring"""







											_lowerCAmelCase:Optional[Any]									='''cpu'''  # ensure determinism for the device-dependent torch.Generator
											_lowerCAmelCase:List[str]									=self.get_dummy_components()
											_lowerCAmelCase:Dict									=StableDiffusionPanoramaPipeline(**SCREAMING_SNAKE_CASE_)
											_lowerCAmelCase:Optional[Any]									=sd_pipe.to(SCREAMING_SNAKE_CASE_)
											sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_)

											_lowerCAmelCase:int									=self.get_dummy_inputs(SCREAMING_SNAKE_CASE_)
											_lowerCAmelCase:List[str]									='''french fries'''
											_lowerCAmelCase:List[str]									=sd_pipe(**SCREAMING_SNAKE_CASE_     ,negative_prompt=SCREAMING_SNAKE_CASE_)
											_lowerCAmelCase:List[Any]									=output.images
											_lowerCAmelCase:Union[str, Any]									=image[0, -3:, -3:, -1]

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

											_lowerCAmelCase:Dict									=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       __UpperCamelCase     (							self      :	Optional[Any])						->       Optional[Any]:




											"""simple docstring"""







											_lowerCAmelCase:Optional[Any]									='''cpu'''  # ensure determinism for the device-dependent torch.Generator
											_lowerCAmelCase:Optional[int]									=self.get_dummy_components()
											_lowerCAmelCase:List[str]									=StableDiffusionPanoramaPipeline(**SCREAMING_SNAKE_CASE_)
											_lowerCAmelCase:List[str]									=sd_pipe.to(SCREAMING_SNAKE_CASE_)
											sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_)

											_lowerCAmelCase:Any									=self.get_dummy_inputs(SCREAMING_SNAKE_CASE_)
											_lowerCAmelCase:Union[str, Any]									=sd_pipe(**SCREAMING_SNAKE_CASE_     ,view_batch_size=2)
											_lowerCAmelCase:Tuple									=output.images
											_lowerCAmelCase:Optional[Any]									=image[0, -3:, -3:, -1]

											assert image.shape == (1, 64, 64, 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       __UpperCamelCase     (							self      :	Optional[int])						->       Optional[int]:




											"""simple docstring"""







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

											_lowerCAmelCase:List[str]									=self.get_dummy_inputs(SCREAMING_SNAKE_CASE_)
											_lowerCAmelCase:Optional[Any]									=sd_pipe(**SCREAMING_SNAKE_CASE_).images
											_lowerCAmelCase:Optional[int]									=image[0, -3:, -3:, -1]

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

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




											"""simple docstring"""







											_lowerCAmelCase:Dict									='''cpu'''  # ensure determinism for the device-dependent torch.Generator
											_lowerCAmelCase:Dict									=self.get_dummy_components()
											_lowerCAmelCase:Union[str, Any]									=PNDMScheduler(
											    beta_start=0.00085     ,beta_end=0.012     ,beta_schedule='''scaled_linear'''     ,skip_prk_steps=SCREAMING_SNAKE_CASE_)
											_lowerCAmelCase:Union[str, Any]									=StableDiffusionPanoramaPipeline(**SCREAMING_SNAKE_CASE_)
											_lowerCAmelCase:Union[str, Any]									=sd_pipe.to(SCREAMING_SNAKE_CASE_)
											sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_)

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

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

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





						def       __UpperCamelCase     (							self      :	int)						->       Union[str, Any]:




											"""simple docstring"""







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





						def       __UpperCamelCase     (							self      :	Any     ,a__      :	Tuple=0)						->       Dict:




											"""simple docstring"""







											_lowerCAmelCase:Tuple									=torch.manual_seed(SCREAMING_SNAKE_CASE_)
											_lowerCAmelCase:Optional[Any]									={
											    '''prompt''': '''a photo of the dolomites''',
											    '''generator''': generator,
											    '''num_inference_steps''': 3,
											    '''guidance_scale''': 7.5,
											    '''output_type''': '''numpy''',
											}
											return inputs





						def       __UpperCamelCase     (							self      :	Union[str, Any])						->       Any:




											"""simple docstring"""







											_lowerCAmelCase:int									='''stabilityai/stable-diffusion-2-base'''
											_lowerCAmelCase:Tuple									=DDIMScheduler.from_pretrained(SCREAMING_SNAKE_CASE_     ,subfolder='''scheduler''')
											_lowerCAmelCase:Tuple									=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:Optional[int]									=self.get_inputs()
											_lowerCAmelCase:Any									=pipe(**SCREAMING_SNAKE_CASE_).images
											_lowerCAmelCase:Dict									=image[0, -3:, -3:, -1].flatten()

											assert image.shape == (1, 512, 2048, 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       __UpperCamelCase     (							self      :	Optional[Any])						->       str:




											"""simple docstring"""







											_lowerCAmelCase:int									=StableDiffusionPanoramaPipeline.from_pretrained(
											    '''stabilityai/stable-diffusion-2-base'''     ,safety_checker=SCREAMING_SNAKE_CASE_)
											_lowerCAmelCase:Optional[Any]									=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:Union[str, Any]									=self.get_inputs()
											_lowerCAmelCase:str									=pipe(**SCREAMING_SNAKE_CASE_).images
											_lowerCAmelCase:Dict									=image[0, -3:, -3:, -1].flatten()

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

											_lowerCAmelCase:Dict									=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       __UpperCamelCase     (							self      :	Tuple)						->       int:




											"""simple docstring"""







											_lowerCAmelCase:Union[str, Any]									=0

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

																					_lowerCAmelCase:Union[str, Any]									=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, 64, 256)
																					_lowerCAmelCase:Optional[Any]									=latents[0, -3:, -3:, -1]

																					_lowerCAmelCase:Union[str, Any]									=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:int									='''stabilityai/stable-diffusion-2-base'''
											_lowerCAmelCase:int									=DDIMScheduler.from_pretrained(SCREAMING_SNAKE_CASE_     ,subfolder='''scheduler''')
											_lowerCAmelCase:Tuple									=StableDiffusionPanoramaPipeline.from_pretrained(SCREAMING_SNAKE_CASE_     ,scheduler=SCREAMING_SNAKE_CASE_     ,safety_checker=SCREAMING_SNAKE_CASE_)
											_lowerCAmelCase:str									=pipe.to(SCREAMING_SNAKE_CASE_)
											pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_)
											pipe.enable_attention_slicing()

											_lowerCAmelCase:int									=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       __UpperCamelCase     (							self      :	int)						->       Any:




											"""simple docstring"""







											torch.cuda.empty_cache()
											torch.cuda.reset_max_memory_allocated()
											torch.cuda.reset_peak_memory_stats()

											_lowerCAmelCase:Union[str, Any]									='''stabilityai/stable-diffusion-2-base'''
											_lowerCAmelCase:str									=DDIMScheduler.from_pretrained(SCREAMING_SNAKE_CASE_     ,subfolder='''scheduler''')
											_lowerCAmelCase:Tuple									=StableDiffusionPanoramaPipeline.from_pretrained(SCREAMING_SNAKE_CASE_     ,scheduler=SCREAMING_SNAKE_CASE_     ,safety_checker=SCREAMING_SNAKE_CASE_)
											_lowerCAmelCase:Any									=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:Tuple									=self.get_inputs()
											_lowerCAmelCase:Optional[int]									=pipe(**SCREAMING_SNAKE_CASE_)

											_lowerCAmelCase:List[Any]									=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 							UpperCAmelCase		(		snake_case			:					int      ,       snake_case			:					int    ):
					return x if y == 0 else greatest_common_divisor(snake_case      ,       x % y    )





def 							UpperCAmelCase		(		snake_case			:					int      ,       snake_case			:					int    ):
					return (x * y) // greatest_common_divisor(snake_case      ,       snake_case    )





def 							UpperCAmelCase		(		snake_case			:					int = 20    ):
					_lowerCAmelCase:List[Any]									=  1
					for i in range(1      ,       n + 1    ):
										_lowerCAmelCase:List[str]									=  lcm(snake_case      ,       snake_case    )
					return g


if __name__ == "__main__":
				print(F"{solution() = }")






