

"""simple docstring"""


import gc
import random
import unittest

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

import diffusers
from diffusers import (
    AutoencoderKL,
    EulerDiscreteScheduler,
    StableDiffusionLatentUpscalePipeline,
    StableDiffusionPipeline,
    UNetaDConditionModel,
)
from diffusers.schedulers import KarrasDiffusionSchedulers
from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS, TEXT_GUIDED_IMAGE_VARIATION_PARAMS
from ..test_pipelines_common import PipelineKarrasSchedulerTesterMixin, PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()






def        a__       (       __SCREAMING_SNAKE_CASE					)      ->      Optional[int]:
		__lowerCAmelCase:			Optional[Any]        =     [tensor.shape for tensor in tensor_list]
		return all(shape == shapes[0] for shape in shapes[1:]					)





class        snake_case      (							lowercase__,				lowercase__,				lowercase__,				unittest.TestCase    ):
				SCREAMING_SNAKE_CASE_  : int   =    StableDiffusionLatentUpscalePipeline
				SCREAMING_SNAKE_CASE_  : List[Any]   =    TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {
				    """height""",
				    """width""",
				    """cross_attention_kwargs""",
				    """negative_prompt_embeds""",
				    """prompt_embeds""",
				}
				SCREAMING_SNAKE_CASE_  : Dict   =    PipelineTesterMixin.required_optional_params - {"""num_images_per_prompt"""}
				SCREAMING_SNAKE_CASE_  : int   =    TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
				SCREAMING_SNAKE_CASE_  : Tuple   =    frozenset(
				    []    )  # TO-DO: update image_params once pipeline is refactored with VaeImageProcessor.preprocess
				SCREAMING_SNAKE_CASE_  : List[str]   =    frozenset([]    )

				SCREAMING_SNAKE_CASE_  : Union[str, Any]   =    True

				@property
				def 				lowercase_	(      self				:							Optional[Any])->  Any:



						'''simple docstring'''


						__lowerCAmelCase:			Dict        =     1
						__lowerCAmelCase:			Optional[Any]        =     4
						__lowerCAmelCase:			Optional[Any]        =     (1_6, 1_6)

						__lowerCAmelCase:			Union[str, Any]        =     floats_tensor((batch_size, num_channels) + sizes	,    rng=random.Random(0)).to(UpperCAmelCase__)
						return image

				def 				lowercase_	(      self				:							Optional[int])->  Any:



						'''simple docstring'''


						torch.manual_seed(0)
						__lowerCAmelCase:			int        =     UNetaDConditionModel(
						    act_fn="gelu"	,    attention_head_dim=8	,    norm_num_groups=UpperCAmelCase__	,    block_out_channels=[3_2, 3_2, 6_4, 6_4]	,    time_cond_proj_dim=1_6_0	,    conv_in_kernel=1	,    conv_out_kernel=1	,    cross_attention_dim=3_2	,    down_block_types=(
						        "KDownBlock2D",
						        "KCrossAttnDownBlock2D",
						        "KCrossAttnDownBlock2D",
						        "KCrossAttnDownBlock2D",
						    )	,    in_channels=8	,    mid_block_type=UpperCAmelCase__	,    only_cross_attention=UpperCAmelCase__	,    out_channels=5	,    resnet_time_scale_shift="scale_shift"	,    time_embedding_type="fourier"	,    timestep_post_act="gelu"	,    up_block_types=("KCrossAttnUpBlock2D", "KCrossAttnUpBlock2D", "KCrossAttnUpBlock2D", "KUpBlock2D")	,    )
						__lowerCAmelCase:			int        =     AutoencoderKL(
						    block_out_channels=[3_2, 3_2, 6_4, 6_4]	,    in_channels=3	,    out_channels=3	,    down_block_types=[
						        "DownEncoderBlock2D",
						        "DownEncoderBlock2D",
						        "DownEncoderBlock2D",
						        "DownEncoderBlock2D",
						    ]	,    up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D", "UpDecoderBlock2D", "UpDecoderBlock2D"]	,    latent_channels=4	,    )
						__lowerCAmelCase:			Tuple        =     EulerDiscreteScheduler(prediction_type="sample")
						__lowerCAmelCase:			Union[str, 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	,    hidden_act="quick_gelu"	,    projection_dim=5_1_2	,    )
						__lowerCAmelCase:			Any        =     CLIPTextModel(UpperCAmelCase__)
						__lowerCAmelCase:			Tuple        =     CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip")

						__lowerCAmelCase:			Tuple        =     {
						    '''unet''': model.eval(),
						    '''vae''': vae.eval(),
						    '''scheduler''': scheduler,
						    '''text_encoder''': text_encoder,
						    '''tokenizer''': tokenizer,
						}

						return components

				def 				lowercase_	(      self				:							Tuple	,    UpperCamelCase__				:							Union[str, Any]	,    UpperCamelCase__				:							Tuple=0)->  Optional[Any]:



						'''simple docstring'''


						if str(UpperCAmelCase__).startswith("mps"):
								__lowerCAmelCase:			int        =     torch.manual_seed(UpperCAmelCase__)
						else:
								__lowerCAmelCase:			Any        =     torch.Generator(device=UpperCAmelCase__).manual_seed(UpperCAmelCase__)
						__lowerCAmelCase:			Optional[Any]        =     {
						    '''prompt''': '''A painting of a squirrel eating a burger''',
						    '''image''': self.dummy_image.cpu(),
						    '''generator''': generator,
						    '''num_inference_steps''': 2,
						    '''output_type''': '''numpy''',
						}
						return inputs

				def 				lowercase_	(      self				:							str)->  List[Any]:



						'''simple docstring'''


						__lowerCAmelCase:			Optional[int]        =     '''cpu'''

						__lowerCAmelCase:			Union[str, Any]        =     self.get_dummy_components()
						__lowerCAmelCase:			Tuple        =     self.pipeline_class(**UpperCAmelCase__)
						pipe.to(UpperCAmelCase__)
						pipe.set_progress_bar_config(disable=UpperCAmelCase__)

						__lowerCAmelCase:			List[str]        =     self.get_dummy_inputs(UpperCAmelCase__)
						__lowerCAmelCase:			int        =     pipe(**UpperCAmelCase__).images
						__lowerCAmelCase:			str        =     image[0, -3:, -3:, -1]

						self.assertEqual(image.shape	,    (1, 2_5_6, 2_5_6, 3))
						__lowerCAmelCase:			Optional[Any]        =     np.array(
						    [0.47222412, 0.41921633, 0.44717434, 0.46874192, 0.42588258, 0.46150726, 0.4677534, 0.45583832, 0.48579055])
						__lowerCAmelCase:			List[str]        =     np.abs(image_slice.flatten() - expected_slice).max()
						self.assertLessEqual(UpperCAmelCase__	,    1e-3)

				def 				lowercase_	(      self				:							Optional[Any])->  Tuple:



						'''simple docstring'''


						super().test_attention_slicing_forward_pass(expected_max_diff=7e-3)

				def 				lowercase_	(      self				:							List[str])->  Optional[Any]:



						'''simple docstring'''


						super().test_cpu_offload_forward_pass(expected_max_diff=3e-3)

				def 				lowercase_	(      self				:							Optional[Any])->  Optional[Any]:



						'''simple docstring'''


						super().test_dict_tuple_outputs_equivalent(expected_max_difference=3e-3)

				def 				lowercase_	(      self				:							Optional[Any])->  List[str]:



						'''simple docstring'''


						super().test_inference_batch_single_identical(expected_max_diff=7e-3)

				def 				lowercase_	(      self				:							int)->  str:



						'''simple docstring'''


						super().test_pt_np_pil_outputs_equivalent(expected_max_diff=3e-3)

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



						'''simple docstring'''


						super().test_save_load_local(expected_max_difference=3e-3)

				def 				lowercase_	(      self				:							str)->  List[Any]:



						'''simple docstring'''


						super().test_save_load_optional_components(expected_max_difference=3e-3)




				def 				lowercase_	(      self				:							Any)->  Optional[Any]:



						'''simple docstring'''


						__lowerCAmelCase:			Optional[Any]        =     [
						    '''DDIMScheduler''',
						    '''DDPMScheduler''',
						    '''PNDMScheduler''',
						    '''HeunDiscreteScheduler''',
						    '''EulerAncestralDiscreteScheduler''',
						    '''KDPM2DiscreteScheduler''',
						    '''KDPM2AncestralDiscreteScheduler''',
						    '''DPMSolverSDEScheduler''',
						]
						__lowerCAmelCase:			Optional[int]        =     self.get_dummy_components()
						__lowerCAmelCase:			Any        =     self.pipeline_class(**UpperCAmelCase__)

						# make sure that PNDM does not need warm-up
						pipe.scheduler.register_to_config(skip_prk_steps=UpperCAmelCase__)

						pipe.to(UpperCAmelCase__)
						pipe.set_progress_bar_config(disable=UpperCAmelCase__)
						__lowerCAmelCase:			Optional[int]        =     self.get_dummy_inputs(UpperCAmelCase__)
						__lowerCAmelCase:			Any        =     2

						__lowerCAmelCase:			Any        =     []
						for scheduler_enum in KarrasDiffusionSchedulers:
								if scheduler_enum.name in skip_schedulers:
										# no sigma schedulers are not supported
										# no schedulers
										continue

								__lowerCAmelCase:			Optional[int]        =     getattr(UpperCAmelCase__	,    scheduler_enum.name)
								__lowerCAmelCase:			Tuple        =     scheduler_cls.from_config(pipe.scheduler.config)
								__lowerCAmelCase:			Any        =     pipe(**UpperCAmelCase__)[0]
								outputs.append(UpperCAmelCase__)

						assert check_same_shape(UpperCAmelCase__)





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

				def 				lowercase_	(      self				:							Tuple)->  Optional[Any]:



						'''simple docstring'''


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

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



						'''simple docstring'''


						__lowerCAmelCase:			Union[str, Any]        =     torch.manual_seed(3_3)

						__lowerCAmelCase:			Tuple        =     StableDiffusionPipeline.from_pretrained("CompVis/stable-diffusion-v1-4"	,    torch_dtype=torch.floataa)
						pipe.to("cuda")

						__lowerCAmelCase:			List[Any]        =     StableDiffusionLatentUpscalePipeline.from_pretrained(
						    "stabilityai/sd-x2-latent-upscaler"	,    torch_dtype=torch.floataa)
						upscaler.to("cuda")

						__lowerCAmelCase:			Tuple        =     '''a photo of an astronaut high resolution, unreal engine, ultra realistic'''

						__lowerCAmelCase:			List[Any]        =     pipe(UpperCAmelCase__	,    generator=UpperCAmelCase__	,    output_type="latent").images

						__lowerCAmelCase:			str        =     upscaler(
						    prompt=UpperCAmelCase__	,    image=UpperCAmelCase__	,    num_inference_steps=2_0	,    guidance_scale=0	,    generator=UpperCAmelCase__	,    output_type="np"	,    ).images[0]

						__lowerCAmelCase:			Any        =     load_numpy(
						    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/latent-upscaler/astronaut_1024.npy")
						assert np.abs((expected_image - image).mean()) < 5e-2




				def 				lowercase_	(      self				:							List[str])->  Optional[int]:



						'''simple docstring'''


						__lowerCAmelCase:			int        =     torch.manual_seed(3_3)

						__lowerCAmelCase:			Any        =     StableDiffusionLatentUpscalePipeline.from_pretrained(
						    "stabilityai/sd-x2-latent-upscaler"	,    torch_dtype=torch.floataa)
						upscaler.to("cuda")

						__lowerCAmelCase:			Tuple        =     '''the temple of fire by Ross Tran and Gerardo Dottori, oil on canvas'''

						__lowerCAmelCase:			int        =     load_image(
						    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/latent-upscaler/fire_temple_512.png")

						__lowerCAmelCase:			str        =     upscaler(
						    prompt=UpperCAmelCase__	,    image=UpperCAmelCase__	,    num_inference_steps=2_0	,    guidance_scale=0	,    generator=UpperCAmelCase__	,    output_type="np"	,    ).images[0]

						__lowerCAmelCase:			Optional[Any]        =     load_numpy(
						    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/latent-upscaler/fire_temple_1024.npy")
						assert np.abs((expected_image - image).max()) < 5e-2





'''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)





