






import gc
import random
import unittest

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

from diffusers import AutoencoderKL, CycleDiffusionPipeline, DDIMScheduler, UNetaDConditionModel
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, skip_mps

from ..pipeline_params import (
    IMAGE_TO_IMAGE_IMAGE_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_PARAMS,
)
from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()

class 						lowerCAmelCase   (       __a					,				__a					,				unittest.TestCase	):

					'''simple docstring'''

					_A  :	Tuple     =					CycleDiffusionPipeline
					_A  :	Tuple     =					TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {
					    '''negative_prompt''',
					    '''height''',
					    '''width''',
					    '''negative_prompt_embeds''',
					}
					_A  :	Optional[int]     =					PipelineTesterMixin.required_optional_params - {'''latents'''}
					_A  :	Union[str, Any]     =					TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({'''source_prompt'''}	)
					_A  :	str     =					IMAGE_TO_IMAGE_IMAGE_PARAMS
					_A  :	Optional[int]     =					IMAGE_TO_IMAGE_IMAGE_PARAMS



					def 					lowerCAmelCase (     self :		List[str]							)	->     str:


												"""simple docstring"""

												torch.manual_seed(0							)
												__lowercase					:							Union[str, Any]			=   UNetaDConditionModel(
												    block_out_channels=(32, 64)						,   layers_per_block=2						,   sample_size=32						,   in_channels=4						,   out_channels=4						,   down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""")						,   up_block_types=("""CrossAttnUpBlock2D""", """UpBlock2D""")						,   cross_attention_dim=32						,   )
												__lowercase					:							List[str]			=   DDIMScheduler(
												    beta_start=0.00085						,   beta_end=0.012						,   beta_schedule="""scaled_linear"""						,   num_train_timesteps=1000						,   clip_sample=__a						,   set_alpha_to_one=__a						,   )
												torch.manual_seed(0							)
												__lowercase					:							List[Any]			=   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[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						,   )
												__lowercase					:							Any			=   CLIPTextModel(__a							)
												__lowercase					:							str			=   CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""							)

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



					def 					lowerCAmelCase (     self :		str						,   __a :		Any						,   __a :		Optional[int]=0							)	->     Optional[Any]:


												"""simple docstring"""

												__lowercase					:							str			=   floats_tensor((1, 3, 32, 32)						,   rng=random.Random(__a							)							).to(__a							)
												__lowercase					:							str			=   image / 2 + 0.5
												if str(__a							).startswith("""mps"""							):
																			__lowercase					:							Optional[int]			=   torch.manual_seed(__a							)
												else:
																			__lowercase					:							List[Any]			=   torch.Generator(device=__a							).manual_seed(__a							)
												__lowercase					:							List[Any]			=   {
												    """prompt""": """An astronaut riding an elephant""",
												    """source_prompt""": """An astronaut riding a horse""",
												    """image""": image,
												    """generator""": generator,
												    """num_inference_steps""": 2,
												    """eta""": 0.1,
												    """strength""": 0.8,
												    """guidance_scale""": 3,
												    """source_guidance_scale""": 1,
												    """output_type""": """numpy""",
												}
												return inputs



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


												"""simple docstring"""

												__lowercase					:							Union[str, Any]			=   """cpu"""  # ensure determinism for the device-dependent torch.Generator

												__lowercase					:							int			=   self.get_dummy_components()
												__lowercase					:							Optional[Any]			=   CycleDiffusionPipeline(**__a							)
												__lowercase					:							List[Any]			=   pipe.to(__a							)
												pipe.set_progress_bar_config(disable=__a							)

												__lowercase					:							List[str]			=   self.get_dummy_inputs(__a							)
												__lowercase					:							Optional[Any]			=   pipe(**__a							)
												__lowercase					:							int			=   output.images

												__lowercase					:							str			=   images[0, -3:, -3:, -1]

												assert images.shape == (1, 32, 32, 3)
												__lowercase					:							List[Any]			=   np.array([0.4459, 0.4943, 0.4544, 0.6643, 0.5474, 0.4327, 0.5701, 0.5959, 0.5179]							)

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



					@unittest.skipIf(torch_device != """cuda"""						,   """This test requires a GPU"""							)
					def 					lowerCAmelCase (     self :		int							)	->     Union[str, Any]:


												"""simple docstring"""

												__lowercase					:							Union[str, Any]			=   self.get_dummy_components()
												for name, module in components.items():
																			if hasattr(__a						,   """half"""							):
																										__lowercase					:							Any			=   module.half()
												__lowercase					:							List[str]			=   CycleDiffusionPipeline(**__a							)
												__lowercase					:							Tuple			=   pipe.to(__a							)
												pipe.set_progress_bar_config(disable=__a							)

												__lowercase					:							Optional[int]			=   self.get_dummy_inputs(__a							)
												__lowercase					:							List[Any]			=   pipe(**__a							)
												__lowercase					:							Union[str, Any]			=   output.images

												__lowercase					:							Union[str, Any]			=   images[0, -3:, -3:, -1]

												assert images.shape == (1, 32, 32, 3)
												__lowercase					:							Optional[int]			=   np.array([0.3506, 0.4543, 0.446, 0.4575, 0.5195, 0.4155, 0.5273, 0.518, 0.4116]							)

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



					@skip_mps
					def 					lowerCAmelCase (     self :		List[str]							)	->     Optional[Any]:


												"""simple docstring"""

												return super().test_save_load_local()



					@unittest.skip("""non-deterministic pipeline"""							)
					def 					lowerCAmelCase (     self :		List[str]							)	->     int:


												"""simple docstring"""

												return super().test_inference_batch_single_identical()



					@skip_mps
					def 					lowerCAmelCase (     self :		List[str]							)	->     Tuple:


												"""simple docstring"""

												return super().test_dict_tuple_outputs_equivalent()



					@skip_mps
					def 					lowerCAmelCase (     self :		List[Any]							)	->     List[Any]:


												"""simple docstring"""

												return super().test_save_load_optional_components()



					@skip_mps
					def 					lowerCAmelCase (     self :		List[Any]							)	->     List[str]:


												"""simple docstring"""

												return super().test_attention_slicing_forward_pass()







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

					'''simple docstring'''

					def 					lowerCAmelCase (     self :		List[Any]							)	->     Dict:


												"""simple docstring"""

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



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


												"""simple docstring"""

												__lowercase					:							List[str]			=   load_image(
												    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
												    """/cycle-diffusion/black_colored_car.png"""							)
												__lowercase					:							Dict			=   load_numpy(
												    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/cycle-diffusion/blue_colored_car_fp16.npy"""							)
												__lowercase					:							Optional[int]			=   init_image.resize((512, 512)							)

												__lowercase					:							List[str]			=   """CompVis/stable-diffusion-v1-4"""
												__lowercase					:							int			=   DDIMScheduler.from_pretrained(__a						,   subfolder="""scheduler"""							)
												__lowercase					:							List[str]			=   CycleDiffusionPipeline.from_pretrained(
												    __a						,   scheduler=__a						,   safety_checker=__a						,   torch_dtype=torch.floataa						,   revision="""fp16"""							)

												pipe.to(__a							)
												pipe.set_progress_bar_config(disable=__a							)
												pipe.enable_attention_slicing()

												__lowercase					:							Dict			=   """A black colored car"""
												__lowercase					:							Optional[Any]			=   """A blue colored car"""

												__lowercase					:							List[str]			=   torch.manual_seed(0							)
												__lowercase					:							List[Any]			=   pipe(
												    prompt=__a						,   source_prompt=__a						,   image=__a						,   num_inference_steps=100						,   eta=0.1						,   strength=0.85						,   guidance_scale=3						,   source_guidance_scale=1						,   generator=__a						,   output_type="""np"""						,   )
												__lowercase					:							Tuple			=   output.images

												# the values aren't exactly equal, but the images look the same visually
												assert np.abs(image - expected_image							).max() < 5E-1



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


												"""simple docstring"""

												__lowercase					:							Optional[int]			=   load_image(
												    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
												    """/cycle-diffusion/black_colored_car.png"""							)
												__lowercase					:							Optional[int]			=   load_numpy(
												    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/cycle-diffusion/blue_colored_car.npy"""							)
												__lowercase					:							Optional[int]			=   init_image.resize((512, 512)							)

												__lowercase					:							Optional[Any]			=   """CompVis/stable-diffusion-v1-4"""
												__lowercase					:							Dict			=   DDIMScheduler.from_pretrained(__a						,   subfolder="""scheduler"""							)
												__lowercase					:							Optional[int]			=   CycleDiffusionPipeline.from_pretrained(__a						,   scheduler=__a						,   safety_checker=__a							)

												pipe.to(__a							)
												pipe.set_progress_bar_config(disable=__a							)
												pipe.enable_attention_slicing()

												__lowercase					:							Tuple			=   """A black colored car"""
												__lowercase					:							Any			=   """A blue colored car"""

												__lowercase					:							List[str]			=   torch.manual_seed(0							)
												__lowercase					:							List[str]			=   pipe(
												    prompt=__a						,   source_prompt=__a						,   image=__a						,   num_inference_steps=100						,   eta=0.1						,   strength=0.85						,   guidance_scale=3						,   source_guidance_scale=1						,   generator=__a						,   output_type="""np"""						,   )
												__lowercase					:							Optional[Any]			=   output.images

												assert np.abs(image - expected_image							).max() < 2E-2







import math

class 						lowerCAmelCase   :

					'''simple docstring'''

					def __init__(     self :		Tuple						,   __a :		int=0							)	->     Optional[Any]:  # a graph with Node 0,1,...,N-1


												"""simple docstring"""

												__lowercase					:							Any			=   n
												__lowercase					:							Optional[int]			=   [
												    [math.inf for j in range(0						,   __a							)] for i in range(0						,   __a							)
												]  # adjacency matrix for weight
												__lowercase					:							Dict			=   [
												    [math.inf for j in range(0						,   __a							)] for i in range(0						,   __a							)
												]  # dp[i][j] stores minimum distance from i to j



					def 					lowerCAmelCase (     self :		int						,   __a :		Optional[int]						,   __a :		Tuple						,   __a :		Dict							)	->     Dict:


												"""simple docstring"""

												__lowercase					:							Any			=   w



					def 					lowerCAmelCase (     self :		List[str]							)	->     Tuple:


												"""simple docstring"""

												for k in range(0						,   self.n							):
																			for i in range(0						,   self.n							):
																										for j in range(0						,   self.n							):
																																	__lowercase					:							List[str]			=   min(self.dp[i][j]						,   self.dp[i][k] + self.dp[k][j]							)



					def 					lowerCAmelCase (     self :		Any						,   __a :		Any						,   __a :		str							)	->     int:


												"""simple docstring"""

												return self.dp[u][v]


if __name__ == "__main__":
	lowerCamelCase       :       int        =				Graph(5)
	graph.add_edge(0, 2, 9)
	graph.add_edge(0, 4, 10)
	graph.add_edge(1, 3, 5)
	graph.add_edge(2, 3, 7)
	graph.add_edge(3, 0, 10)
	graph.add_edge(3, 1, 2)
	graph.add_edge(3, 2, 1)
	graph.add_edge(3, 4, 6)
	graph.add_edge(4, 1, 3)
	graph.add_edge(4, 2, 4)
	graph.add_edge(4, 3, 9)
	graph.floyd_warshall()
	graph.show_min(1, 4)
	graph.show_min(0, 3)