



class        _SCREAMING_SNAKE_CASE		:





   def __init__(self):
       '''simple docstring'''







       __UpperCAmelCase			 =0
       __UpperCAmelCase			 =0
       __UpperCAmelCase			 ={}





   def 	A__      (self    ,  UpperCAmelCase):
       '''simple docstring'''







       if vertex not in self.adjacency:
           __UpperCAmelCase			 ={}
           self.num_vertices += 1





   def 	A__      (self    ,  UpperCAmelCase    ,  UpperCAmelCase    ,  UpperCAmelCase):
       '''simple docstring'''







       self.add_vertex(lowerCamelCase__)
       self.add_vertex(lowerCamelCase__)

       if head == tail:
           return

       __UpperCAmelCase			 =weight
       __UpperCAmelCase			 =weight





   def 	A__      (self):
       '''simple docstring'''







       __UpperCAmelCase			 =self.get_edges()
       for edge in edges:
           __UpperCAmelCase			 =edge
           edges.remove((tail, head, weight))
       for i in range(len(lowerCamelCase__)):
           __UpperCAmelCase			 =list(edges[i])

       edges.sort(key=lambda UpperCAmelCase: e[2])
       for i in range(len(lowerCamelCase__) - 1):
           if edges[i][2] >= edges[i + 1][2]:
               __UpperCAmelCase			 =edges[i][2] + 1
       for edge in edges:
           __UpperCAmelCase			 =edge
           __UpperCAmelCase			 =weight
           __UpperCAmelCase			 =weight





   def __str__(self):
       '''simple docstring'''







       __UpperCAmelCase			 =""""""
       for tail in self.adjacency:
           for head in self.adjacency[tail]:
               __UpperCAmelCase			 =self.adjacency[head][tail]
               string += f"""{head} -> {tail} == {weight}\n"""
       return string.rstrip('''\n''')





   def 	A__      (self):
       '''simple docstring'''







       __UpperCAmelCase			 =[]
       for tail in self.adjacency:
           for head in self.adjacency[tail]:
               output.append((tail, head, self.adjacency[head][tail]))
       return output





   def 	A__      (self):
       '''simple docstring'''







       return self.adjacency.keys()





   @staticmethod
   def 	A__      (UpperCAmelCase=None    ,  UpperCAmelCase=None):
       '''simple docstring'''







       __UpperCAmelCase			 =Graph()
       if vertices is None:
           __UpperCAmelCase			 =[]
       if edges is None:
           __UpperCAmelCase			 =[]
       for vertex in vertices:
           g.add_vertex(lowerCamelCase__)
       for edge in edges:
           g.add_edge(*lowerCamelCase__)
       return g



   class        _SCREAMING_SNAKE_CASE		:





      def __init__(self):
          '''simple docstring'''







          __UpperCAmelCase			 ={}
          __UpperCAmelCase			 ={}





      def __len__(self):
          '''simple docstring'''







          return len(self.parent)





      def 	A__      (self    ,  UpperCAmelCase):
          '''simple docstring'''







          if item in self.parent:
              return self.find(lowerCamelCase__)

          __UpperCAmelCase			 =item
          __UpperCAmelCase			 =0
          return item





      def 	A__      (self    ,  UpperCAmelCase):
          '''simple docstring'''







          if item not in self.parent:
              return self.make_set(lowerCamelCase__)
          if item != self.parent[item]:
              __UpperCAmelCase			 =self.find(self.parent[item])
          return self.parent[item]






      def 	A__      (self    ,  UpperCAmelCase    ,  UpperCAmelCase):
          '''simple docstring'''







          __UpperCAmelCase			 =self.find(lowerCamelCase__)
          __UpperCAmelCase			 =self.find(lowerCamelCase__)

          if roota == roota:
              return roota

          if self.rank[roota] > self.rank[roota]:
              __UpperCAmelCase			 =roota
              return roota

          if self.rank[roota] < self.rank[roota]:
              __UpperCAmelCase			 =roota
              return roota

          if self.rank[roota] == self.rank[roota]:
              self.rank[roota] += 1
              __UpperCAmelCase			 =roota
              return roota
          return None







   @staticmethod
   def 	A__      (UpperCAmelCase):
       '''simple docstring'''







       __UpperCAmelCase			 =graph.num_vertices

       __UpperCAmelCase			 =Graph.UnionFind()
       __UpperCAmelCase			 =[]
       while num_components > 1:
           __UpperCAmelCase			 ={}
           for vertex in graph.get_vertices():
               __UpperCAmelCase			 =-1

           __UpperCAmelCase			 =graph.get_edges()
           for edge in edges:
               __UpperCAmelCase			 =edge
               edges.remove((tail, head, weight))
           for edge in edges:
               __UpperCAmelCase			 =edge
               __UpperCAmelCase			 =union_find.find(lowerCamelCase__)
               __UpperCAmelCase			 =union_find.find(lowerCamelCase__)
               if seta != seta:
                   if cheap_edge[seta] == -1 or cheap_edge[seta][2] > weight:
                       __UpperCAmelCase			 =[head, tail, weight]

                   if cheap_edge[seta] == -1 or cheap_edge[seta][2] > weight:
                       __UpperCAmelCase			 =[head, tail, weight]
           for vertex in cheap_edge:
               if cheap_edge[vertex] != -1:
                   __UpperCAmelCase			 =cheap_edge[vertex]
                   if union_find.find(lowerCamelCase__) != union_find.find(lowerCamelCase__):
                       union_find.union(lowerCamelCase__    ,  lowerCamelCase__)
                       mst_edges.append(cheap_edge[vertex])
                       __UpperCAmelCase			 =num_components - 1
       __UpperCAmelCase			 =Graph.build(edges=lowerCamelCase__)
       return mst











import gc
import random
import unittest

import numpy as np
import torch

from diffusers import DDIMScheduler, KandinskyVaaPipeline, KandinskyVaaPriorPipeline, UNetaDConditionModel, VQModel
from diffusers.utils import floats_tensor, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference


enable_full_determinism()







class 		_A						( UpperCAmelCase_	,				unittest.TestCase ):
  lowercase_						:			int						=					KandinskyVaaPipeline
  lowercase_						:			Union[str, Any]						=					[
      '''image_embeds''',
      '''negative_image_embeds''',
  ]
  lowercase_						:			int						=					['''image_embeds''', '''negative_image_embeds''']
  lowercase_						:			str						=					[
      '''generator''',
      '''height''',
      '''width''',
      '''latents''',
      '''guidance_scale''',
      '''num_inference_steps''',
      '''return_dict''',
      '''guidance_scale''',
      '''num_images_per_prompt''',
      '''output_type''',
      '''return_dict''',
  ]
  lowercase_						:			str						=					False

  @property
  def    a					(    self						:	int			):
     """simple docstring"""

     return 32

  @property
  def    a					(    self						:	str			):
     """simple docstring"""

     return 32

  @property
  def    a					(    self						:	Optional[int]			):
     """simple docstring"""

     return self.time_input_dim

  @property
  def    a					(    self						:	Optional[int]			):
     """simple docstring"""

     return self.time_input_dim * 4

  @property
  def    a					(    self						:	Optional[Any]			):
     """simple docstring"""

     return 1_00

  @property
  def    a					(    self						:	str			):
     """simple docstring"""

     torch.manual_seed(0			)

     __UpperCamelCase	:			int					=					{
         """in_channels""": 4,
         # Out channels is double in channels because predicts mean and variance
         """out_channels""": 8,
         """addition_embed_type""": """image""",
         """down_block_types""": ("""ResnetDownsampleBlock2D""", """SimpleCrossAttnDownBlock2D"""),
         """up_block_types""": ("""SimpleCrossAttnUpBlock2D""", """ResnetUpsampleBlock2D"""),
         """mid_block_type""": """UNetMidBlock2DSimpleCrossAttn""",
         """block_out_channels""": (self.block_out_channels_a, self.block_out_channels_a * 2),
         """layers_per_block""": 1,
         """encoder_hid_dim""": self.text_embedder_hidden_size,
         """encoder_hid_dim_type""": """image_proj""",
         """cross_attention_dim""": self.cross_attention_dim,
         """attention_head_dim""": 4,
         """resnet_time_scale_shift""": """scale_shift""",
         """class_embed_type""": None,
     }

     __UpperCamelCase	:			Any					=					UNetaDConditionModel(**lowerCamelCase__			)
     return model

  @property
  def    a					(    self						:	Union[str, Any]			):
     """simple docstring"""

     return {
         "block_out_channels": [32, 64],
         "down_block_types": ["DownEncoderBlock2D", "AttnDownEncoderBlock2D"],
         "in_channels": 3,
         "latent_channels": 4,
         "layers_per_block": 1,
         "norm_num_groups": 8,
         "norm_type": "spatial",
         "num_vq_embeddings": 12,
         "out_channels": 3,
         "up_block_types": [
             "AttnUpDecoderBlock2D",
             "UpDecoderBlock2D",
         ],
         "vq_embed_dim": 4,
     }

  @property
  def    a					(    self						:	int			):
     """simple docstring"""

     torch.manual_seed(0			)
     __UpperCamelCase	:			Tuple					=					VQModel(**self.dummy_movq_kwargs			)
     return model

  def    a					(    self						:	Tuple			):
     """simple docstring"""

     __UpperCamelCase	:			str					=					self.dummy_unet
     __UpperCamelCase	:			Optional[int]					=					self.dummy_movq

     __UpperCamelCase	:			List[str]					=					DDIMScheduler(
         num_train_timesteps=10_00   ,				beta_schedule="""linear"""   ,				beta_start=0.0_0085   ,				beta_end=0.012   ,				clip_sample=lowerCamelCase__   ,				set_alpha_to_one=lowerCamelCase__   ,				steps_offset=1   ,				prediction_type="""epsilon"""   ,				thresholding=lowerCamelCase__   ,				)

     __UpperCamelCase	:			str					=					{
         """unet""": unet,
         """scheduler""": scheduler,
         """movq""": movq,
     }
     return components

  def    a					(    self						:	Optional[int]   ,				lowerCamelCase__						:	Optional[Any]   ,				lowerCamelCase__						:	Any=0			):
     """simple docstring"""

     __UpperCamelCase	:			Tuple					=					floats_tensor((1, self.text_embedder_hidden_size)   ,				rng=random.Random(lowerCamelCase__			)			).to(lowerCamelCase__			)
     __UpperCamelCase	:			Optional[int]					=					floats_tensor((1, self.text_embedder_hidden_size)   ,				rng=random.Random(seed + 1			)			).to(
         lowerCamelCase__			)
     if str(lowerCamelCase__			).startswith("""mps"""			):
        __UpperCamelCase	:			Optional[int]					=					torch.manual_seed(lowerCamelCase__			)
     else:
        __UpperCamelCase	:			int					=					torch.Generator(device=lowerCamelCase__			).manual_seed(lowerCamelCase__			)
     __UpperCamelCase	:			Dict					=					{
         """image_embeds""": image_embeds,
         """negative_image_embeds""": negative_image_embeds,
         """generator""": generator,
         """height""": 64,
         """width""": 64,
         """guidance_scale""": 4.0,
         """num_inference_steps""": 2,
         """output_type""": """np""",
     }
     return inputs

  def    a					(    self						:	Dict			):
     """simple docstring"""

     __UpperCamelCase	:			Dict					=					"""cpu"""

     __UpperCamelCase	:			Dict					=					self.get_dummy_components()

     __UpperCamelCase	:			Union[str, Any]					=					self.pipeline_class(**lowerCamelCase__			)
     __UpperCamelCase	:			int					=					pipe.to(lowerCamelCase__			)

     pipe.set_progress_bar_config(disable=lowerCamelCase__			)

     __UpperCamelCase	:			List[Any]					=					pipe(**self.get_dummy_inputs(lowerCamelCase__			)			)
     __UpperCamelCase	:			List[Any]					=					output.images

     __UpperCamelCase	:			int					=					pipe(
         **self.get_dummy_inputs(lowerCamelCase__			)   ,				return_dict=lowerCamelCase__   ,				)[0]

     __UpperCamelCase	:			List[str]					=					image[0, -3:, -3:, -1]
     __UpperCamelCase	:			Tuple					=					image_from_tuple[0, -3:, -3:, -1]

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

     __UpperCamelCase	:			int					=					np.array(
         [0.623_7976, 1.0, 0.3644_1332, 1.0, 0.7063_9634, 0.2987_7186, 0.8565_2125, 0.521_6843, 0.5445_4046]			)

     assert (
         np.abs(image_slice.flatten() - expected_slice			).max() < 1e-2
     ), f' expected_slice {expected_slice}, but got {image_slice.flatten()}'

     assert (
         np.abs(image_from_tuple_slice.flatten() - expected_slice			).max() < 1e-2
     ), f' expected_slice {expected_slice}, but got {image_from_tuple_slice.flatten()}'







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

  def    a					(    self						:	Optional[int]			):
     """simple docstring"""

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

  def    a					(    self						:	List[Any]			):
     """simple docstring"""

     __UpperCamelCase	:			int					=					load_numpy(
         """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
         """/kandinskyv22/kandinskyv22_text2img_cat_fp16.npy"""			)

     __UpperCamelCase	:			List[str]					=					KandinskyVaaPriorPipeline.from_pretrained(
         """kandinsky-community/kandinsky-2-2-prior"""   ,				torch_dtype=torch.floataa			)
     pipe_prior.to(lowerCamelCase__			)

     __UpperCamelCase	:			int					=					KandinskyVaaPipeline.from_pretrained(
         """kandinsky-community/kandinsky-2-2-decoder"""   ,				torch_dtype=torch.floataa			)
     __UpperCamelCase	:			Optional[int]					=					pipeline.to(lowerCamelCase__			)
     pipeline.set_progress_bar_config(disable=lowerCamelCase__			)

     __UpperCamelCase	:			Optional[Any]					=					"""red cat, 4k photo"""

     __UpperCamelCase	:			Tuple					=					torch.Generator(device="""cuda"""			).manual_seed(0			)
     __UpperCamelCase	,     __UpperCamelCase	:			Union[str, Any]					=					pipe_prior(
         lowerCamelCase__   ,				generator=lowerCamelCase__   ,				num_inference_steps=5   ,				negative_prompt=""""""   ,				).to_tuple()

     __UpperCamelCase	:			Any					=					torch.Generator(device="""cuda"""			).manual_seed(0			)
     __UpperCamelCase	:			Union[str, Any]					=					pipeline(
         image_embeds=lowerCamelCase__   ,				negative_image_embeds=lowerCamelCase__   ,				generator=lowerCamelCase__   ,				num_inference_steps=1_00   ,				output_type="""np"""   ,				)

     __UpperCamelCase	:			Any					=					output.images[0]

     assert image.shape == (5_12, 5_12, 3)

     assert_mean_pixel_difference(lowerCamelCase__   ,				lowerCamelCase__			)



