




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			(		_lowerCAmelCase			,						_lowerCAmelCase			,						_lowerCAmelCase			,						unittest.TestCase		):
     """simple docstring"""

     _snake_case:	List[str]     =StableDiffusionModelEditingPipeline
     _snake_case:	Any     =TEXT_TO_IMAGE_PARAMS
     _snake_case:	Dict     =TEXT_TO_IMAGE_BATCH_PARAMS
     _snake_case:	Optional[Any]     =TEXT_TO_IMAGE_IMAGE_PARAMS
     _snake_case:	Dict     =TEXT_TO_IMAGE_IMAGE_PARAMS




     def  __snake_case   (    self  :   Optional[Any]			)				->       Dict:
           torch.manual_seed(0			)
           lowerCamelCase__        =				UNetaDConditionModel(
               block_out_channels=(3_2, 6_4)	,  layers_per_block=2	,  sample_size=3_2	,  in_channels=4	,  out_channels=4	,  down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')	,  up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D')	,  cross_attention_dim=3_2	,  )
           lowerCamelCase__        =				DDIMScheduler()
           torch.manual_seed(0			)
           lowerCamelCase__        =				AutoencoderKL(
               block_out_channels=[3_2, 6_4]	,  in_channels=3	,  out_channels=3	,  down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D']	,  up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D']	,  latent_channels=4	,  )
           torch.manual_seed(0			)
           lowerCamelCase__        =				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	,  )
           lowerCamelCase__        =				CLIPTextModel(A__			)
           lowerCamelCase__        =				CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'			)

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




     def  __snake_case   (    self  :   str	,  A__  :   Union[str, Any]	,  A__  :   Dict=0			)				->       List[str]:
           lowerCamelCase__        =				torch.manual_seed(A__			)
           lowerCamelCase__        =				{
               '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  __snake_case   (    self  :   str			)				->       Optional[int]:
           lowerCamelCase__        =				'cpu'  # ensure determinism for the device-dependent torch.Generator
           lowerCamelCase__        =				self.get_dummy_components()
           lowerCamelCase__        =				StableDiffusionModelEditingPipeline(**A__			)
           lowerCamelCase__        =				sd_pipe.to(A__			)
           sd_pipe.set_progress_bar_config(disable=A__			)

           lowerCamelCase__        =				self.get_dummy_inputs(A__			)
           lowerCamelCase__        =				sd_pipe(**A__			).images
           lowerCamelCase__        =				image[0, -3:, -3:, -1]
           assert image.shape == (1, 6_4, 6_4, 3)

           lowerCamelCase__        =				np.array([0.4755, 0.5132, 0.4976, 0.3904, 0.3554, 0.4765, 0.5139, 0.5158, 0.4889]			)

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




     def  __snake_case   (    self  :   Dict			)				->       Tuple:
           lowerCamelCase__        =				'cpu'  # ensure determinism for the device-dependent torch.Generator
           lowerCamelCase__        =				self.get_dummy_components()
           lowerCamelCase__        =				StableDiffusionModelEditingPipeline(**A__			)
           lowerCamelCase__        =				sd_pipe.to(A__			)
           sd_pipe.set_progress_bar_config(disable=A__			)

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

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

           lowerCamelCase__        =				np.array([0.4992, 0.5101, 0.5004, 0.3949, 0.3604, 0.4735, 0.5216, 0.5204, 0.4913]			)

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




     def  __snake_case   (    self  :   Optional[Any]			)				->       Optional[int]:
           lowerCamelCase__        =				'cpu'  # ensure determinism for the device-dependent torch.Generator
           lowerCamelCase__        =				self.get_dummy_components()
           lowerCamelCase__        =				EulerAncestralDiscreteScheduler(
               beta_start=0.00085	,  beta_end=0.012	,  beta_schedule='scaled_linear'			)
           lowerCamelCase__        =				StableDiffusionModelEditingPipeline(**A__			)
           lowerCamelCase__        =				sd_pipe.to(A__			)
           sd_pipe.set_progress_bar_config(disable=A__			)

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

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

           lowerCamelCase__        =				np.array([0.4747, 0.5372, 0.4779, 0.4982, 0.5543, 0.4816, 0.5238, 0.4904, 0.5027]			)

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




     def  __snake_case   (    self  :   Tuple			)				->       Dict:
           lowerCamelCase__        =				'cpu'  # ensure determinism for the device-dependent torch.Generator
           lowerCamelCase__        =				self.get_dummy_components()
           lowerCamelCase__        =				PNDMScheduler()
           lowerCamelCase__        =				StableDiffusionModelEditingPipeline(**A__			)
           lowerCamelCase__        =				sd_pipe.to(A__			)
           sd_pipe.set_progress_bar_config(disable=A__			)

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




     def  __snake_case   (    self  :   Any			)				->       int:
           super().test_inference_batch_single_identical(expected_max_diff=5E-3			)




     def  __snake_case   (    self  :   str			)				->       List[Any]:
           super().test_attention_slicing_forward_pass(expected_max_diff=5E-3			)






@slow
@require_torch_gpu
class 			A			(		unittest.TestCase		):
     """simple docstring"""

     def  __snake_case   (    self  :   Union[str, Any]			)				->       Any:
           super().tearDown()
           gc.collect()
           torch.cuda.empty_cache()




     def  __snake_case   (    self  :   Optional[int]	,  A__  :   Union[str, Any]=0			)				->       str:
           lowerCamelCase__        =				torch.manual_seed(A__			)
           lowerCamelCase__        =				{
               'prompt': 'A field of roses',
               'generator': generator,
               'num_inference_steps': 3,
               'guidance_scale': 7.5,
               'output_type': 'numpy',
           }
           return inputs




     def  __snake_case   (    self  :   Optional[Any]			)				->       Optional[int]:
           lowerCamelCase__        =				'CompVis/stable-diffusion-v1-4'
           lowerCamelCase__        =				StableDiffusionModelEditingPipeline.from_pretrained(A__	,  safety_checker=A__			)
           pipe.to(A__			)
           pipe.set_progress_bar_config(disable=A__			)
           pipe.enable_attention_slicing()

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

           assert image.shape == (1, 5_1_2, 5_1_2, 3)

           lowerCamelCase__        =				np.array(
               [0.6749496, 0.6386453, 0.51443267, 0.66094905, 0.61921215, 0.5491332, 0.5744417, 0.58075106, 0.5174658]			)

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

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

           assert image.shape == (1, 5_1_2, 5_1_2, 3)

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




     def  __snake_case   (    self  :   Optional[Any]			)				->       Union[str, Any]:
           torch.cuda.empty_cache()
           torch.cuda.reset_max_memory_allocated()
           torch.cuda.reset_peak_memory_stats()

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

           lowerCamelCase__        =				self.get_inputs()
           lowerCamelCase__        =				pipe(**A__			)

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





def 			lowerCAmelCase_			(  lowerCamelCase:       int     ,				lowerCamelCase:       list[tuple[int, int, int]]						)					->			list[tuple[int, int, int]]:


      '''simple docstring'''




      lowerCamelCase__        =				sorted(lowerCamelCase     ,				key=lambda lowerCamelCase						: edge[2]						)

      lowerCamelCase__        =				list(range(lowerCamelCase						)						)

      def find_parent(lowerCamelCase:       int						):
            if i != parent[i]:
                  lowerCamelCase__        =				find_parent(parent[i]						)
            return parent[i]

      lowerCamelCase__        =				0
      lowerCamelCase__        =				[]

      for edge in edges:
            lowerCamelCase__        =				find_parent(edge[0]						)
            lowerCamelCase__        =				find_parent(edge[1]						)
            if parent_a != parent_b:
                  minimum_spanning_tree_cost += edge[2]
                  minimum_spanning_tree.append(lowerCamelCase						)
                  lowerCamelCase__        =				parent_b

      return minimum_spanning_tree


if __name__ == "__main__":  # pragma: no cover
      __SCREAMING_SNAKE_CASE    ,  __SCREAMING_SNAKE_CASE    :   Tuple       =list(map(int, input().strip().split()))
      __SCREAMING_SNAKE_CASE    :   Optional[Any]       =[]

      for _ in range(num_edges):
            __SCREAMING_SNAKE_CASE    ,  __SCREAMING_SNAKE_CASE    ,  __SCREAMING_SNAKE_CASE    :   Optional[int]       =(int(x) for x in input().strip().split())
            edges.append((nodea, nodea, cost))

      kruskal(num_nodes, edges)