

'''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 		__SCREAMING_SNAKE_CASE							(			lowercase__						,							lowercase__						,							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     :		List[str]   ):
										'''simple docstring'''
										torch.manual_seed(0   )
										lowercase :							Dict    		=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		,					)
										lowercase :							int    		=DDIMScheduler()
										torch.manual_seed(0   )
										lowercase :							Optional[int]    		=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   )
										lowercase :							Optional[Any]    		=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		,					)
										lowercase :							Optional[Any]    		=CLIPTextModel(UpperCAmelCase__   )
										lowercase :							List[Any]    		=CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''   )

										lowercase :							int    		={
										    '''unet''': unet,
										    '''scheduler''': scheduler,
										    '''vae''': vae,
										    '''text_encoder''': text_encoder,
										    '''tokenizer''': tokenizer,
										    '''safety_checker''': None,
										    '''feature_extractor''': None,
										}
										return components







				def  lowerCamelCase_	(       self     :		Dict		,					UpperCAmelCase__     :		Union[str, Any]		,					UpperCAmelCase__     :		Any=0   ):
										'''simple docstring'''
										lowercase :							str    		=torch.manual_seed(UpperCAmelCase__   )
										lowercase :							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  lowerCamelCase_	(       self     :		Union[str, Any]   ):
										'''simple docstring'''
										lowercase :							Optional[int]    		='''cpu'''  # ensure determinism for the device-dependent torch.Generator
										lowercase :							Optional[int]    		=self.get_dummy_components()
										lowercase :							Union[str, Any]    		=StableDiffusionPanoramaPipeline(**UpperCAmelCase__   )
										lowercase :							Optional[Any]    		=sd_pipe.to(UpperCAmelCase__   )
										sd_pipe.set_progress_bar_config(disable=UpperCAmelCase__   )

										lowercase :							List[str]    		=self.get_dummy_inputs(UpperCAmelCase__   )
										lowercase :							str    		=sd_pipe(**UpperCAmelCase__   ).images
										lowercase :							str    		=image[0, -3:, -3:, -1]
										assert image.shape == (1, 64, 64, 3)

										lowercase :							int    		=np.array([0.61_86, 0.53_74, 0.49_15, 0.41_35, 0.41_14, 0.45_63, 0.51_28, 0.49_77, 0.47_57]   )

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







				def  lowerCamelCase_	(       self     :		Dict   ):
										'''simple docstring'''
										super().test_inference_batch_consistent(batch_sizes=[1, 2]   )







				def  lowerCamelCase_	(       self     :		List[str]   ):
										'''simple docstring'''
										super().test_inference_batch_single_identical(batch_size=2		,					expected_max_diff=3.25E-3   )







				def  lowerCamelCase_	(       self     :		Union[str, Any]   ):
										'''simple docstring'''
										lowercase :							Optional[Any]    		='''cpu'''  # ensure determinism for the device-dependent torch.Generator
										lowercase :							Any    		=self.get_dummy_components()
										lowercase :							int    		=StableDiffusionPanoramaPipeline(**UpperCAmelCase__   )
										lowercase :							List[Any]    		=sd_pipe.to(UpperCAmelCase__   )
										sd_pipe.set_progress_bar_config(disable=UpperCAmelCase__   )

										lowercase :							Dict    		=self.get_dummy_inputs(UpperCAmelCase__   )
										lowercase :							Tuple    		='''french fries'''
										lowercase :							Union[str, Any]    		=sd_pipe(**UpperCAmelCase__		,					negative_prompt=UpperCAmelCase__   )
										lowercase :							Tuple    		=output.images
										lowercase :							Any    		=image[0, -3:, -3:, -1]

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

										lowercase :							Union[str, Any]    		=np.array([0.61_87, 0.53_75, 0.49_15, 0.41_36, 0.41_14, 0.45_63, 0.51_28, 0.49_76, 0.47_57]   )

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







				def  lowerCamelCase_	(       self     :		Union[str, Any]   ):
										'''simple docstring'''
										lowercase :							List[str]    		='''cpu'''  # ensure determinism for the device-dependent torch.Generator
										lowercase :							Tuple    		=self.get_dummy_components()
										lowercase :							Tuple    		=StableDiffusionPanoramaPipeline(**UpperCAmelCase__   )
										lowercase :							Union[str, Any]    		=sd_pipe.to(UpperCAmelCase__   )
										sd_pipe.set_progress_bar_config(disable=UpperCAmelCase__   )

										lowercase :							List[str]    		=self.get_dummy_inputs(UpperCAmelCase__   )
										lowercase :							int    		=sd_pipe(**UpperCAmelCase__		,					view_batch_size=2   )
										lowercase :							Optional[int]    		=output.images
										lowercase :							List[str]    		=image[0, -3:, -3:, -1]

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

										lowercase :							List[str]    		=np.array([0.61_87, 0.53_75, 0.49_15, 0.41_36, 0.41_14, 0.45_63, 0.51_28, 0.49_76, 0.47_57]   )

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







				def  lowerCamelCase_	(       self     :		Optional[int]   ):
										'''simple docstring'''
										lowercase :							int    		='''cpu'''  # ensure determinism for the device-dependent torch.Generator
										lowercase :							str    		=self.get_dummy_components()
										lowercase :							str    		=EulerAncestralDiscreteScheduler(
										    beta_start=0.0_00_85		,					beta_end=0.0_12		,					beta_schedule='''scaled_linear'''   )
										lowercase :							Optional[int]    		=StableDiffusionPanoramaPipeline(**UpperCAmelCase__   )
										lowercase :							Tuple    		=sd_pipe.to(UpperCAmelCase__   )
										sd_pipe.set_progress_bar_config(disable=UpperCAmelCase__   )

										lowercase :							int    		=self.get_dummy_inputs(UpperCAmelCase__   )
										lowercase :							Tuple    		=sd_pipe(**UpperCAmelCase__   ).images
										lowercase :							Any    		=image[0, -3:, -3:, -1]

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

										lowercase :							Optional[int]    		=np.array([0.40_24, 0.65_10, 0.49_01, 0.53_78, 0.58_13, 0.56_22, 0.47_95, 0.44_67, 0.49_52]   )

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







				def  lowerCamelCase_	(       self     :		Union[str, Any]   ):
										'''simple docstring'''
										lowercase :							Tuple    		='''cpu'''  # ensure determinism for the device-dependent torch.Generator
										lowercase :							int    		=self.get_dummy_components()
										lowercase :							Optional[int]    		=PNDMScheduler(
										    beta_start=0.0_00_85		,					beta_end=0.0_12		,					beta_schedule='''scaled_linear'''		,					skip_prk_steps=UpperCAmelCase__   )
										lowercase :							Optional[int]    		=StableDiffusionPanoramaPipeline(**UpperCAmelCase__   )
										lowercase :							int    		=sd_pipe.to(UpperCAmelCase__   )
										sd_pipe.set_progress_bar_config(disable=UpperCAmelCase__   )

										lowercase :							Union[str, Any]    		=self.get_dummy_inputs(UpperCAmelCase__   )
										lowercase :							Dict    		=sd_pipe(**UpperCAmelCase__   ).images
										lowercase :							Optional[int]    		=image[0, -3:, -3:, -1]

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

										lowercase :							Optional[int]    		=np.array([0.63_91, 0.62_91, 0.48_61, 0.51_34, 0.55_52, 0.45_78, 0.50_32, 0.50_23, 0.45_39]   )

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





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







				def  lowerCamelCase_	(       self     :		Dict   ):
										'''simple docstring'''
										super().tearDown()
										gc.collect()
										torch.cuda.empty_cache()







				def  lowerCamelCase_	(       self     :		str		,					UpperCAmelCase__     :		Tuple=0   ):
										'''simple docstring'''
										lowercase :							Dict    		=torch.manual_seed(UpperCAmelCase__   )
										lowercase :							Optional[int]    		={
										    '''prompt''': '''a photo of the dolomites''',
										    '''generator''': generator,
										    '''num_inference_steps''': 3,
										    '''guidance_scale''': 7.5,
										    '''output_type''': '''numpy''',
										}
										return inputs







				def  lowerCamelCase_	(       self     :		int   ):
										'''simple docstring'''
										lowercase :							Union[str, Any]    		='''stabilityai/stable-diffusion-2-base'''
										lowercase :							Tuple    		=DDIMScheduler.from_pretrained(UpperCAmelCase__		,					subfolder='''scheduler'''   )
										lowercase :							Optional[Any]    		=StableDiffusionPanoramaPipeline.from_pretrained(UpperCAmelCase__		,					scheduler=UpperCAmelCase__		,					safety_checker=UpperCAmelCase__   )
										pipe.to(UpperCAmelCase__   )
										pipe.set_progress_bar_config(disable=UpperCAmelCase__   )
										pipe.enable_attention_slicing()

										lowercase :							List[Any]    		=self.get_inputs()
										lowercase :							List[Any]    		=pipe(**UpperCAmelCase__   ).images
										lowercase :							Union[str, Any]    		=image[0, -3:, -3:, -1].flatten()

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

										lowercase :							str    		=np.array(
										    [
										        0.36_96_83_92,
										        0.27_02_53_72,
										        0.32_44_67_66,
										        0.28_37_93_87,
										        0.36_36_32_74,
										        0.30_73_33_47,
										        0.27_10_00_27,
										        0.27_05_41_25,
										        0.25_53_60_96,
										    ]   )

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







				def  lowerCamelCase_	(       self     :		Union[str, Any]   ):
										'''simple docstring'''
										lowercase :							Optional[Any]    		=StableDiffusionPanoramaPipeline.from_pretrained(
										    '''stabilityai/stable-diffusion-2-base'''		,					safety_checker=UpperCAmelCase__   )
										lowercase :							List[str]    		=LMSDiscreteScheduler.from_config(pipe.scheduler.config   )
										pipe.to(UpperCAmelCase__   )
										pipe.set_progress_bar_config(disable=UpperCAmelCase__   )
										pipe.enable_attention_slicing()

										lowercase :							Optional[Any]    		=self.get_inputs()
										lowercase :							List[Any]    		=pipe(**UpperCAmelCase__   ).images
										lowercase :							Any    		=image[0, -3:, -3:, -1].flatten()

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

										lowercase :							Tuple    		=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     :		Dict   ):
										'''simple docstring'''
										lowercase :							Any    		=0

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

																						lowercase :							List[str]    		=np.array(
																						    [
																						        0.18_68_18_69,
																						        0.33_90_78_16,
																						        0.5_36_12_76,
																						        0.14_43_28_65,
																						        -0.02_85_66_11,
																						        -0.73_94_11_23,
																						        0.23_39_79_87,
																						        0.47_32_26_82,
																						        -0.37_82_31_64,
																						    ]   )
																						assert np.abs(latents_slice.flatten() - expected_slice   ).max() < 5E-2
																elif step == 2:
																						lowercase :							Union[str, Any]    		=latents.detach().cpu().numpy()
																						assert latents.shape == (1, 4, 64, 256)
																						lowercase :							Any    		=latents[0, -3:, -3:, -1]

																						lowercase :							int    		=np.array(
																						    [
																						        0.18_53_96_45,
																						        0.33_98_72_48,
																						        0.5_37_85_59,
																						        0.14_43_71_42,
																						        -0.02_45_52_61,
																						        -0.7_33_83_17,
																						        0.23_99_07_55,
																						        0.47_35_62_72,
																						        -0.3_78_65_05,
																						    ]   )

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

										lowercase :							Union[str, Any]    		=False

										lowercase :							Any    		='''stabilityai/stable-diffusion-2-base'''
										lowercase :							List[Any]    		=DDIMScheduler.from_pretrained(UpperCAmelCase__		,					subfolder='''scheduler'''   )
										lowercase :							Any    		=StableDiffusionPanoramaPipeline.from_pretrained(UpperCAmelCase__		,					scheduler=UpperCAmelCase__		,					safety_checker=UpperCAmelCase__   )
										lowercase :							Union[str, Any]    		=pipe.to(UpperCAmelCase__   )
										pipe.set_progress_bar_config(disable=UpperCAmelCase__   )
										pipe.enable_attention_slicing()

										lowercase :							Tuple    		=self.get_inputs()
										pipe(**UpperCAmelCase__		,					callback=UpperCAmelCase__		,					callback_steps=1   )
										assert callback_fn.has_been_called
										assert number_of_steps == 3







				def  lowerCamelCase_	(       self     :		str   ):
										'''simple docstring'''
										torch.cuda.empty_cache()
										torch.cuda.reset_max_memory_allocated()
										torch.cuda.reset_peak_memory_stats()

										lowercase :							Optional[Any]    		='''stabilityai/stable-diffusion-2-base'''
										lowercase :							str    		=DDIMScheduler.from_pretrained(UpperCAmelCase__		,					subfolder='''scheduler'''   )
										lowercase :							Optional[int]    		=StableDiffusionPanoramaPipeline.from_pretrained(UpperCAmelCase__		,					scheduler=UpperCAmelCase__		,					safety_checker=UpperCAmelCase__   )
										lowercase :							str    		=pipe.to(UpperCAmelCase__   )
										pipe.set_progress_bar_config(disable=UpperCAmelCase__   )
										pipe.enable_attention_slicing(1   )
										pipe.enable_sequential_cpu_offload()

										lowercase :							str    		=self.get_inputs()
										lowercase :							Tuple    		=pipe(**UpperCAmelCase__   )

										lowercase :							Optional[int]    		=torch.cuda.max_memory_allocated()
										# make sure that less than 5.2 GB is allocated
										assert mem_bytes < 5.5 * 10**9








'''simple docstring'''





from collections import defaultdict






def 				_lowerCAmelCase			(   __magic_name__						:     int						)				->  int:
						lowercase :							Optional[Any]    		=1
						lowercase :							Union[str, Any]    		=True
						for v in tree[start]:
												if v not in visited:
																		ret += dfs(__magic_name__						)
						if ret % 2 == 0:
												cuts.append(__magic_name__						)
						return ret






def 				_lowerCAmelCase			(   )				->  int:
						dfs(1						)


if __name__ == "__main__":
							UpperCamelCase_						,   UpperCamelCase_    						=       10, 9
							UpperCamelCase_    						=       defaultdict(list)
							UpperCamelCase_    						=       {}
							UpperCamelCase_    						=       []
							UpperCamelCase_    						=       0
							UpperCamelCase_    						=       [(2, 1), (3, 1), (4, 3), (5, 2), (6, 1), (7, 2), (8, 6), (9, 8), (10, 8)]
							for u, v in edges:
														tree[u].append(v)
														tree[v].append(u)
							even_tree()
							print(len(cuts) - 1)





