





import gc
import random
import unittest

import torch

from diffusers import (
    IFImgaImgPipeline,
    IFImgaImgSuperResolutionPipeline,
    IFInpaintingPipeline,
    IFInpaintingSuperResolutionPipeline,
    IFPipeline,
    IFSuperResolutionPipeline,
)
from diffusers.models.attention_processor import AttnAddedKVProcessor
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import floats_tensor, load_numpy, require_torch_gpu, skip_mps, slow, torch_device

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference
from . import IFPipelineTesterMixin





@skip_mps
class UpperCAmelCase_				( _UpperCamelCase     ,		_UpperCamelCase     ,		unittest.TestCase ):
  __lowerCAmelCase   :						Optional[Any]							=   IFPipeline
  __lowerCAmelCase   :						Any							=   TEXT_TO_IMAGE_PARAMS - {"""width""", """height""", """latents"""}
  __lowerCAmelCase   :						Optional[int]							=   TEXT_TO_IMAGE_BATCH_PARAMS
  __lowerCAmelCase   :						Any							=   PipelineTesterMixin.required_optional_params - {"""latents"""}


  def 						__UpperCAmelCase     (							self ):



       """simple docstring"""





       return self._get_dummy_components()


  def 						__UpperCAmelCase     (							self ,__snake_case ,__snake_case=0 ):



       """simple docstring"""





       if str(lowerCamelCase_ ).startswith('''mps''' ):
            A_          =       torch.manual_seed(lowerCamelCase_ )
       else:
            A_          =       torch.Generator(device=lowerCamelCase_ ).manual_seed(lowerCamelCase_ )

       A_          =       {
           'prompt': 'A painting of a squirrel eating a burger',
           'generator': generator,
           'num_inference_steps': 2,
           'output_type': 'numpy',
       }

       return inputs


  def 						__UpperCAmelCase     (							self ):



       """simple docstring"""





       self._test_save_load_optional_components()


  @unittest.skipIf(torch_device != '''cuda''' ,reason='''float16 requires CUDA''' )
  def 						__UpperCAmelCase     (							self ):



       """simple docstring"""





       super().test_save_load_floataa(expected_max_diff=1E-1 )


  def 						__UpperCAmelCase     (							self ):



       """simple docstring"""





       self._test_attention_slicing_forward_pass(expected_max_diff=1E-2 )


  def 						__UpperCAmelCase     (							self ):



       """simple docstring"""





       self._test_save_load_local()


  def 						__UpperCAmelCase     (							self ):



       """simple docstring"""





       self._test_inference_batch_single_identical(
           expected_max_diff=1E-2 ,)




  @unittest.skipIf(
      torch_device != '''cuda''' or not is_xformers_available() ,reason='''XFormers attention is only available with CUDA and `xformers` installed''' ,)
  def 						__UpperCAmelCase     (							self ):



       """simple docstring"""





       self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3 )





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


  def 						__UpperCAmelCase     (							self ):



       """simple docstring"""





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


  def 						__UpperCAmelCase     (							self ):



       """simple docstring"""





       A_          =       IFPipeline.from_pretrained('''DeepFloyd/IF-I-XL-v1.0''' ,variant='''fp16''' ,torch_dtype=torch.floataa )

       A_          =       IFSuperResolutionPipeline.from_pretrained(
           '''DeepFloyd/IF-II-L-v1.0''' ,variant='''fp16''' ,torch_dtype=torch.floataa ,text_encoder=lowerCamelCase_ ,tokenizer=lowerCamelCase_ )

       # pre compute text embeddings and remove T5 to save memory

       pipe_a.text_encoder.to('''cuda''' )

       A_          =       pipe_a.encode_prompt('''anime turtle''' ,device='''cuda''' )

       del pipe_a.tokenizer
       del pipe_a.text_encoder
       gc.collect()

       A_          =       None
       A_          =       None

       pipe_a.enable_model_cpu_offload()
       pipe_a.enable_model_cpu_offload()

       pipe_a.unet.set_attn_processor(AttnAddedKVProcessor() )
       pipe_a.unet.set_attn_processor(AttnAddedKVProcessor() )

       self._test_if(lowerCamelCase_ ,lowerCamelCase_ ,lowerCamelCase_ ,lowerCamelCase_ )

       pipe_a.remove_all_hooks()
       pipe_a.remove_all_hooks()

       # img2img

       A_          =       IFImgaImgPipeline(**pipe_a.components )
       A_          =       IFImgaImgSuperResolutionPipeline(**pipe_a.components )

       pipe_a.enable_model_cpu_offload()
       pipe_a.enable_model_cpu_offload()

       pipe_a.unet.set_attn_processor(AttnAddedKVProcessor() )
       pipe_a.unet.set_attn_processor(AttnAddedKVProcessor() )

       self._test_if_imgaimg(lowerCamelCase_ ,lowerCamelCase_ ,lowerCamelCase_ ,lowerCamelCase_ )

       pipe_a.remove_all_hooks()
       pipe_a.remove_all_hooks()

       # inpainting

       A_          =       IFInpaintingPipeline(**pipe_a.components )
       A_          =       IFInpaintingSuperResolutionPipeline(**pipe_a.components )

       pipe_a.enable_model_cpu_offload()
       pipe_a.enable_model_cpu_offload()

       pipe_a.unet.set_attn_processor(AttnAddedKVProcessor() )
       pipe_a.unet.set_attn_processor(AttnAddedKVProcessor() )

       self._test_if_inpainting(lowerCamelCase_ ,lowerCamelCase_ ,lowerCamelCase_ ,lowerCamelCase_ )


  def 						__UpperCAmelCase     (							self ,__snake_case ,__snake_case ,__snake_case ,__snake_case ):



       """simple docstring"""





       _start_torch_memory_measurement()

       A_          =       torch.Generator(device='''cpu''' ).manual_seed(0 )
       A_          =       pipe_a(
           prompt_embeds=lowerCamelCase_ ,negative_prompt_embeds=lowerCamelCase_ ,num_inference_steps=2 ,generator=lowerCamelCase_ ,output_type='''np''' ,)

       A_          =       output.images[0]

       assert image.shape == (6_4, 6_4, 3)

       A_          =       torch.cuda.max_memory_allocated()
       assert mem_bytes < 1_3 * 1_0**9

       A_          =       load_numpy(
           '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if.npy''' )
       assert_mean_pixel_difference(lowerCamelCase_ ,lowerCamelCase_ )

       # pipeline 2

       _start_torch_memory_measurement()

       A_          =       torch.Generator(device='''cpu''' ).manual_seed(0 )

       A_          =       floats_tensor((1, 3, 6_4, 6_4) ,rng=random.Random(0 ) ).to(lowerCamelCase_ )

       A_          =       pipe_a(
           prompt_embeds=lowerCamelCase_ ,negative_prompt_embeds=lowerCamelCase_ ,image=lowerCamelCase_ ,generator=lowerCamelCase_ ,num_inference_steps=2 ,output_type='''np''' ,)

       A_          =       output.images[0]

       assert image.shape == (2_5_6, 2_5_6, 3)

       A_          =       torch.cuda.max_memory_allocated()
       assert mem_bytes < 4 * 1_0**9

       A_          =       load_numpy(
           '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_superresolution_stage_II.npy''' )
       assert_mean_pixel_difference(lowerCamelCase_ ,lowerCamelCase_ )


  def 						__UpperCAmelCase     (							self ,__snake_case ,__snake_case ,__snake_case ,__snake_case ):



       """simple docstring"""





       _start_torch_memory_measurement()

       A_          =       floats_tensor((1, 3, 6_4, 6_4) ,rng=random.Random(0 ) ).to(lowerCamelCase_ )

       A_          =       torch.Generator(device='''cpu''' ).manual_seed(0 )

       A_          =       pipe_a(
           prompt_embeds=lowerCamelCase_ ,negative_prompt_embeds=lowerCamelCase_ ,image=lowerCamelCase_ ,num_inference_steps=2 ,generator=lowerCamelCase_ ,output_type='''np''' ,)

       A_          =       output.images[0]

       assert image.shape == (6_4, 6_4, 3)

       A_          =       torch.cuda.max_memory_allocated()
       assert mem_bytes < 1_0 * 1_0**9

       A_          =       load_numpy(
           '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_img2img.npy''' )
       assert_mean_pixel_difference(lowerCamelCase_ ,lowerCamelCase_ )

       # pipeline 2

       _start_torch_memory_measurement()

       A_          =       torch.Generator(device='''cpu''' ).manual_seed(0 )

       A_          =       floats_tensor((1, 3, 2_5_6, 2_5_6) ,rng=random.Random(0 ) ).to(lowerCamelCase_ )
       A_          =       floats_tensor((1, 3, 6_4, 6_4) ,rng=random.Random(0 ) ).to(lowerCamelCase_ )

       A_          =       pipe_a(
           prompt_embeds=lowerCamelCase_ ,negative_prompt_embeds=lowerCamelCase_ ,image=lowerCamelCase_ ,original_image=lowerCamelCase_ ,generator=lowerCamelCase_ ,num_inference_steps=2 ,output_type='''np''' ,)

       A_          =       output.images[0]

       assert image.shape == (2_5_6, 2_5_6, 3)

       A_          =       torch.cuda.max_memory_allocated()
       assert mem_bytes < 4 * 1_0**9

       A_          =       load_numpy(
           '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_img2img_superresolution_stage_II.npy''' )
       assert_mean_pixel_difference(lowerCamelCase_ ,lowerCamelCase_ )




  def 						__UpperCAmelCase     (							self ,__snake_case ,__snake_case ,__snake_case ,__snake_case ):



       """simple docstring"""





       _start_torch_memory_measurement()

       A_          =       floats_tensor((1, 3, 6_4, 6_4) ,rng=random.Random(0 ) ).to(lowerCamelCase_ )
       A_          =       floats_tensor((1, 3, 6_4, 6_4) ,rng=random.Random(1 ) ).to(lowerCamelCase_ )

       A_          =       torch.Generator(device='''cpu''' ).manual_seed(0 )
       A_          =       pipe_a(
           prompt_embeds=lowerCamelCase_ ,negative_prompt_embeds=lowerCamelCase_ ,image=lowerCamelCase_ ,mask_image=lowerCamelCase_ ,num_inference_steps=2 ,generator=lowerCamelCase_ ,output_type='''np''' ,)

       A_          =       output.images[0]

       assert image.shape == (6_4, 6_4, 3)

       A_          =       torch.cuda.max_memory_allocated()
       assert mem_bytes < 1_0 * 1_0**9

       A_          =       load_numpy(
           '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_inpainting.npy''' )
       assert_mean_pixel_difference(lowerCamelCase_ ,lowerCamelCase_ )

       # pipeline 2

       _start_torch_memory_measurement()

       A_          =       torch.Generator(device='''cpu''' ).manual_seed(0 )

       A_          =       floats_tensor((1, 3, 6_4, 6_4) ,rng=random.Random(0 ) ).to(lowerCamelCase_ )
       A_          =       floats_tensor((1, 3, 2_5_6, 2_5_6) ,rng=random.Random(0 ) ).to(lowerCamelCase_ )
       A_          =       floats_tensor((1, 3, 2_5_6, 2_5_6) ,rng=random.Random(1 ) ).to(lowerCamelCase_ )

       A_          =       pipe_a(
           prompt_embeds=lowerCamelCase_ ,negative_prompt_embeds=lowerCamelCase_ ,image=lowerCamelCase_ ,mask_image=lowerCamelCase_ ,original_image=lowerCamelCase_ ,generator=lowerCamelCase_ ,num_inference_steps=2 ,output_type='''np''' ,)

       A_          =       output.images[0]

       assert image.shape == (2_5_6, 2_5_6, 3)

       A_          =       torch.cuda.max_memory_allocated()
       assert mem_bytes < 4 * 1_0**9

       A_          =       load_numpy(
           '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_inpainting_superresolution_stage_II.npy''' )
       assert_mean_pixel_difference(lowerCamelCase_ ,lowerCamelCase_ )




def      UpperCAmelCase_    (    )	->				List[str]:
     '''simple docstring'''


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










from __future__ import annotations


def       SCREAMING_SNAKE_CASE__  (       _lowercase     : list[float]   ,    _lowercase     : Tuple			)   ->							int:




		'''simple docstring'''
		print(f"""Vertex\tShortest Distance from vertex {src}"""			)
		for i, d in enumerate(_lowercase			):
				print(f"""{i}\t\t{d}"""			)


def       SCREAMING_SNAKE_CASE__  (       _lowercase     : list[dict[str, int]]   ,    _lowercase     : list[float]   ,    _lowercase     : int			)   ->							Any:




		'''simple docstring'''
		for j in range(_lowercase			):
				lowercase__   ,				lowercase__   ,				lowercase__					:      Dict      =		(graph[j][k] for k in ['src', 'dst', 'weight'])
				if distance[u] != float('inf'			) and distance[u] + w < distance[v]:
						return True
		return False


def       SCREAMING_SNAKE_CASE__  (       _lowercase     : list[dict[str, int]]   ,    _lowercase     : int   ,    _lowercase     : int   ,    _lowercase     : int			)   ->							list[float]:




		'''simple docstring'''
		lowercase__					:      Dict      =		[float('inf'			)] * vertex_count
		lowercase__					:      Dict      =		0.0

		for _ in range(vertex_count - 1			):
				for j in range(_lowercase			):
						lowercase__   ,				lowercase__   ,				lowercase__					:      int      =		(graph[j][k] for k in ['src', 'dst', 'weight'])

						if distance[u] != float('inf'			) and distance[u] + w < distance[v]:
								lowercase__					:      str      =		distance[u] + w

		lowercase__					:      str      =		check_negative_cycle(_lowercase   ,    _lowercase   ,    _lowercase			)
		if negative_cycle_exists:
				raise Exception('Negative cycle found'			)

		return distance


if __name__ == "__main__":
			import doctest

			doctest.testmod()

			__UpperCamelCase:	Optional[int] = int(input("""Enter number of vertices: """).strip())
			__UpperCamelCase:	Union[str, Any] = int(input("""Enter number of edges: """).strip())

			__UpperCamelCase:	list[dict[str, int]] = [{} for _ in range(E)]

			for i in range(E):
						print("""Edge """, i + 1)
						__UpperCamelCase,	__UpperCamelCase,	__UpperCamelCase:	List[str] = (
						    int(x)
						    for x in input("""Enter source, destination, weight: """).strip().split(""" """)
						)
						__UpperCamelCase:	List[Any] = {"""src""": src, """dst""": dest, """weight""": weight}

			__UpperCamelCase:	Optional[int] = int(input("""\nEnter shortest path source:""").strip())
			__UpperCamelCase:	Dict = bellman_ford(graph, V, E, source)
			print_distance(shortest_distance, 0)


