



import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    EulerAncestralDiscreteScheduler,
    PNDMScheduler,
    StableDiffusionModelEditingPipeline,
    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 PipelineKarrasSchedulerTesterMixin, PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()







@skip_mps
class 				a_    (						_snake_case   ,					_snake_case   ,					_snake_case   ,					unittest.TestCase							):
						UpperCamelCase__ :		str										=StableDiffusionModelEditingPipeline
						UpperCamelCase__ :		List[str]										=TEXT_TO_IMAGE_PARAMS
						UpperCamelCase__ :		List[str]										=TEXT_TO_IMAGE_BATCH_PARAMS
						UpperCamelCase__ :		int										=TEXT_TO_IMAGE_IMAGE_PARAMS
						UpperCamelCase__ :		Union[str, Any]										=TEXT_TO_IMAGE_IMAGE_PARAMS

						def       __a			(       self      :Any)						->   Union[str, Any]:
												torch.manual_seed(0)
												UpperCAmelCase_					=	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  ,		)
												UpperCAmelCase_					=	DDIMScheduler()
												torch.manual_seed(0)
												UpperCAmelCase_					=	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)
												UpperCAmelCase_					=	CLIPTextConfig(
												    bos_token_id=0  ,		eos_token_id=2  ,		hidden_size=32  ,		intermediate_size=37  ,		layer_norm_eps=1E-0_5  ,		num_attention_heads=4  ,		num_hidden_layers=5  ,		pad_token_id=1  ,		vocab_size=1000  ,		)
												UpperCAmelCase_					=	CLIPTextModel(_lowercase)
												UpperCAmelCase_					=	CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip''')

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

						def       __a			(       self      :Any  ,		_lowercase      :Optional[int]  ,		_lowercase      :Tuple=0)						->   List[str]:
												UpperCAmelCase_					=	torch.manual_seed(_lowercase)
												UpperCAmelCase_					=	{
												    '''prompt''': '''A field of roses''',
												    '''generator''': generator,
												    # Setting height and width to None to prevent OOMs on CPU.
												    '''height''': None,
												    '''width''': None,
												    '''num_inference_steps''': 2,
												    '''guidance_scale''': 6.0,
												    '''output_type''': '''numpy''',
												}
												return inputs

						def       __a			(       self      :Dict)						->   str:
												UpperCAmelCase_					=	'''cpu'''  # ensure determinism for the device-dependent torch.Generator
												UpperCAmelCase_					=	self.get_dummy_components()
												UpperCAmelCase_					=	StableDiffusionModelEditingPipeline(**_lowercase)
												UpperCAmelCase_					=	sd_pipe.to(_lowercase)
												sd_pipe.set_progress_bar_config(disable=_lowercase)

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

												UpperCAmelCase_					=	np.array([0.4_755, 0.5_132, 0.4_976, 0.3_904, 0.3_554, 0.4_765, 0.5_139, 0.5_158, 0.4_889])

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

						def       __a			(       self      :Optional[int])						->   List[Any]:
												UpperCAmelCase_					=	'''cpu'''  # ensure determinism for the device-dependent torch.Generator
												UpperCAmelCase_					=	self.get_dummy_components()
												UpperCAmelCase_					=	StableDiffusionModelEditingPipeline(**_lowercase)
												UpperCAmelCase_					=	sd_pipe.to(_lowercase)
												sd_pipe.set_progress_bar_config(disable=_lowercase)

												UpperCAmelCase_					=	self.get_dummy_inputs(_lowercase)
												UpperCAmelCase_					=	'''french fries'''
												UpperCAmelCase_					=	sd_pipe(**_lowercase  ,		negative_prompt=_lowercase)
												UpperCAmelCase_					=	output.images
												UpperCAmelCase_					=	image[0, -3:, -3:, -1]

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

												UpperCAmelCase_					=	np.array([0.4_992, 0.5_101, 0.5_004, 0.3_949, 0.3_604, 0.4_735, 0.5_216, 0.5_204, 0.4_913])

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

						def       __a			(       self      :Any)						->   Union[str, Any]:
												UpperCAmelCase_					=	'''cpu'''  # ensure determinism for the device-dependent torch.Generator
												UpperCAmelCase_					=	self.get_dummy_components()
												UpperCAmelCase_					=	EulerAncestralDiscreteScheduler(
												    beta_start=0.00_085  ,		beta_end=0.012  ,		beta_schedule='''scaled_linear''')
												UpperCAmelCase_					=	StableDiffusionModelEditingPipeline(**_lowercase)
												UpperCAmelCase_					=	sd_pipe.to(_lowercase)
												sd_pipe.set_progress_bar_config(disable=_lowercase)

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

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

												UpperCAmelCase_					=	np.array([0.4_747, 0.5_372, 0.4_779, 0.4_982, 0.5_543, 0.4_816, 0.5_238, 0.4_904, 0.5_027])

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

						def       __a			(       self      :Optional[int])						->   Optional[int]:
												UpperCAmelCase_					=	'''cpu'''  # ensure determinism for the device-dependent torch.Generator
												UpperCAmelCase_					=	self.get_dummy_components()
												UpperCAmelCase_					=	PNDMScheduler()
												UpperCAmelCase_					=	StableDiffusionModelEditingPipeline(**_lowercase)
												UpperCAmelCase_					=	sd_pipe.to(_lowercase)
												sd_pipe.set_progress_bar_config(disable=_lowercase)

												UpperCAmelCase_					=	self.get_dummy_inputs(_lowercase)
												# the pipeline does not expect pndm so test if it raises error.
												with self.assertRaises(_lowercase):
																		UpperCAmelCase_					=	sd_pipe(**_lowercase).images

						def       __a			(       self      :str)						->   Optional[Any]:
												super().test_inference_batch_single_identical(expected_max_diff=5E-3)




						def       __a			(       self      :Optional[int])						->   Any:
												super().test_attention_slicing_forward_pass(expected_max_diff=5E-3)







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

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

						def       __a			(       self      :Dict  ,		_lowercase      :Any=0)						->   int:
												UpperCAmelCase_					=	torch.manual_seed(_lowercase)
												UpperCAmelCase_					=	{
												    '''prompt''': '''A field of roses''',
												    '''generator''': generator,
												    '''num_inference_steps''': 3,
												    '''guidance_scale''': 7.5,
												    '''output_type''': '''numpy''',
												}
												return inputs

						def       __a			(       self      :Optional[Any])						->   Union[str, Any]:
												UpperCAmelCase_					=	'''CompVis/stable-diffusion-v1-4'''
												UpperCAmelCase_					=	StableDiffusionModelEditingPipeline.from_pretrained(_lowercase  ,		safety_checker=_lowercase)
												pipe.to(_lowercase)
												pipe.set_progress_bar_config(disable=_lowercase)
												pipe.enable_attention_slicing()

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

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

												UpperCAmelCase_					=	np.array(
												    [0.6_749_496, 0.6_386_453, 0.51_443_267, 0.66_094_905, 0.61_921_215, 0.5_491_332, 0.5_744_417, 0.58_075_106, 0.5_174_658])

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

												# make sure image changes after editing
												pipe.edit_model('''A pack of roses'''  ,		'''A pack of blue roses''')

												UpperCAmelCase_					=	pipe(**_lowercase).images
												UpperCAmelCase_					=	image[0, -3:, -3:, -1].flatten()

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

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




						def       __a			(       self      :Optional[int])						->   Optional[int]:
												torch.cuda.empty_cache()
												torch.cuda.reset_max_memory_allocated()
												torch.cuda.reset_peak_memory_stats()

												UpperCAmelCase_					=	'''CompVis/stable-diffusion-v1-4'''
												UpperCAmelCase_					=	DDIMScheduler.from_pretrained(_lowercase  ,		subfolder='''scheduler''')
												UpperCAmelCase_					=	StableDiffusionModelEditingPipeline.from_pretrained(
												    _lowercase  ,		scheduler=_lowercase  ,		safety_checker=_lowercase)
												UpperCAmelCase_					=	pipe.to(_lowercase)
												pipe.set_progress_bar_config(disable=_lowercase)
												pipe.enable_attention_slicing(1)
												pipe.enable_sequential_cpu_offload()

												UpperCAmelCase_					=	self.get_inputs()
												UpperCAmelCase_					=	pipe(**_lowercase)

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










def 							A     (						__UpperCAmelCase				,   __UpperCAmelCase      )			->			int:



						'''simple docstring'''






						print('''\nVertex Distance'''      )
						for i in range(__UpperCAmelCase      ):
												if dist[i] != float('''inf'''      ):
																		print(__UpperCAmelCase				,   '''\t'''				,   int(dist[i]      )				,   end='''\t'''      )
												else:
																		print(__UpperCAmelCase				,   '''\t'''				,   '''INF'''				,   end='''\t'''      )
												print()







def 							A     (						__UpperCAmelCase				,   __UpperCAmelCase				,   __UpperCAmelCase      )			->			str:



						'''simple docstring'''






						UpperCAmelCase_					=	float('''inf'''      )
						UpperCAmelCase_					=	-1
						for i in range(__UpperCAmelCase      ):
												if (not vset[i]) and mdist[i] < min_val:
																		UpperCAmelCase_					=	i
																		UpperCAmelCase_					=	mdist[i]
						return min_ind







def 							A     (						__UpperCAmelCase				,   __UpperCAmelCase				,   __UpperCAmelCase      )			->			Optional[Any]:



						'''simple docstring'''






						UpperCAmelCase_					=	[float('''inf'''      ) for _ in range(__UpperCAmelCase      )]
						UpperCAmelCase_					=	[False for _ in range(__UpperCAmelCase      )]
						UpperCAmelCase_					=	0.0

						for _ in range(v - 1      ):
												UpperCAmelCase_					=	min_dist(__UpperCAmelCase				,   __UpperCAmelCase				,   __UpperCAmelCase      )
												UpperCAmelCase_					=	True

												for i in range(__UpperCAmelCase      ):
																		if (
																		    (not vset[i])
																		    and graph[u][i] != float('''inf'''      )
																		    and mdist[u] + graph[u][i] < mdist[i]
																		):
																								UpperCAmelCase_					=	mdist[u] + graph[u][i]

						print_dist(__UpperCAmelCase				,   __UpperCAmelCase      )


if __name__ == "__main__":
							UpperCamelCase_      			=  int(input("Enter number of vertices: ").strip())
							UpperCamelCase_      			=  int(input("Enter number of edges: ").strip())

							UpperCamelCase_      			=  [[float("inf") for i in range(V)] for j in range(V)]

							for i in range(V):
														UpperCamelCase_      			=  0.0

							for i in range(E):
														print("\nEdge ", i + 1)
														UpperCamelCase_      			=  int(input("Enter source:").strip())
														UpperCamelCase_      			=  int(input("Enter destination:").strip())
														UpperCamelCase_      			=  float(input("Enter weight:").strip())
														UpperCamelCase_      			=  weight

							UpperCamelCase_      			=  int(input("\nEnter shortest path source:").strip())
							dijkstra(graph, V, gsrc)





