

"""simple docstring"""





from __future__ import annotations

from typing import Any




class 					_lowerCAmelCase  :







 """simple docstring"""







 def __init__(			self							:			Any,					UpperCAmelCase__							:			int	):
    __lowercase								=						num_of_nodes
    __lowercase								=						[]
    __lowercase								=						{}


 def 					_lowercase (			self							:			Optional[Any],					UpperCAmelCase__							:			int,					UpperCAmelCase__							:			int,					UpperCAmelCase__							:			int	):
    self.m_edges.append([u_node, v_node, weight]	)


 def 					_lowercase (			self							:			Union[str, Any],					UpperCAmelCase__							:			int	):

    if self.m_component[u_node] == u_node:
       return u_node
    return self.find_component(self.m_component[u_node]	)


 def 					_lowercase (			self							:			List[Any],					UpperCAmelCase__							:			int	):

    if self.m_component[u_node] != u_node:
       for k in self.m_component:
          __lowercase								=						self.find_component(UpperCAmelCase__	)


 def 					_lowercase (			self							:			Union[str, Any],					UpperCAmelCase__							:			list[int],					UpperCAmelCase__							:			int,					UpperCAmelCase__							:			int	):

    if component_size[u_node] <= component_size[v_node]:
       __lowercase								=						v_node
       component_size[v_node] += component_size[u_node]
       self.set_component(UpperCAmelCase__	)

    elif component_size[u_node] >= component_size[v_node]:
       __lowercase								=						self.find_component(UpperCAmelCase__	)
       component_size[u_node] += component_size[v_node]
       self.set_component(UpperCAmelCase__	)



 def 					_lowercase (			self							:			Any	):
    __lowercase								=						[]
    __lowercase								=						0

    __lowercase								=						[-1] * self.m_num_of_nodes

    # A list of components (initialized to all of the nodes)
    for node in range(self.m_num_of_nodes	):
       self.m_component.update({node: node}	)
       component_size.append(1	)

    __lowercase								=						self.m_num_of_nodes

    while num_of_components > 1:
       for edge in self.m_edges:
          __lowercase		,__lowercase		,__lowercase								=						edge

          __lowercase								=						self.m_component[u]
          __lowercase								=						self.m_component[v]

          if u_component != v_component:

             for component in (u_component, v_component):
                if (
                    minimum_weight_edge[component] == -1
                    or minimum_weight_edge[component][2] > w
                ):
                   __lowercase								=						[u, v, w]

       for edge in minimum_weight_edge:
          if isinstance(UpperCAmelCase__,					UpperCAmelCase__	):
             __lowercase		,__lowercase		,__lowercase								=						edge

             __lowercase								=						self.m_component[u]
             __lowercase								=						self.m_component[v]

             if u_component != v_component:
                mst_weight += w
                self.union(UpperCAmelCase__,					UpperCAmelCase__,					UpperCAmelCase__	)
                print(F"""Added edge [{u} - {v}]\nAdded weight: {w}\n"""	)
                num_of_components -= 1

       __lowercase								=						[-1] * self.m_num_of_nodes
    print(F"""The total weight of the minimal spanning tree is: {mst_weight}"""	)







def   _A  (  )	->						None:
   '''simple docstring'''




if __name__ == "__main__":
   import doctest

   doctest.testmod()







"""simple docstring"""





from typing import Any, Callable, Dict, List, Optional, Union

import torch
from transformers import CLIPImageProcessor, CLIPTextModel, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    DiffusionPipeline,
    LMSDiscreteScheduler,
    PNDMScheduler,
    StableDiffusionPipeline,
    UNetaDConditionModel,
)
from diffusers.pipelines.stable_diffusion import StableDiffusionPipelineOutput
from diffusers.pipelines.stable_diffusion.safety_checker import StableDiffusionSafetyChecker


_a       =							'CompVis/stable-diffusion-v1-1'
_a       =							'CompVis/stable-diffusion-v1-2'
_a       =							'CompVis/stable-diffusion-v1-3'
_a       =							'CompVis/stable-diffusion-v1-4'




class 					_lowerCAmelCase  (	lowercase   ):







 """simple docstring"""







 def __init__(			self							:			Dict,					UpperCAmelCase__							:			AutoencoderKL,					UpperCAmelCase__							:			CLIPTextModel,					UpperCAmelCase__							:			CLIPTokenizer,					UpperCAmelCase__							:			UNetaDConditionModel,					UpperCAmelCase__							:			Union[DDIMScheduler, PNDMScheduler, LMSDiscreteScheduler],					UpperCAmelCase__							:			StableDiffusionSafetyChecker,					UpperCAmelCase__							:			CLIPImageProcessor,					UpperCAmelCase__							:			bool = True,					):
    super()._init_()

    __lowercase								=						StableDiffusionPipeline.from_pretrained(UpperCAmelCase__	)
    __lowercase								=						StableDiffusionPipeline.from_pretrained(UpperCAmelCase__	)
    __lowercase								=						StableDiffusionPipeline.from_pretrained(UpperCAmelCase__	)
    __lowercase								=						StableDiffusionPipeline(
        vae=UpperCAmelCase__,					text_encoder=UpperCAmelCase__,					tokenizer=UpperCAmelCase__,					unet=UpperCAmelCase__,					scheduler=UpperCAmelCase__,					safety_checker=UpperCAmelCase__,					feature_extractor=UpperCAmelCase__,					requires_safety_checker=UpperCAmelCase__,					)

    self.register_modules(pipelinea=self.pipea,					pipelinea=self.pipea,					pipelinea=self.pipea,					pipelinea=self.pipea	)


 @property
 def 					_lowercase (			self							:			List[str]	):
    return {k: getattr(self,					UpperCAmelCase__	) for k in self.config.keys() if not k.startswith("_"	)}


 def 					_lowercase (			self							:			Union[str, Any],					UpperCAmelCase__							:			Optional[Union[str, int]] = "auto"	):
    if slice_size == "auto":
       # half the attention head size is usually a good trade-off between
       # speed and memory
       __lowercase								=						self.unet.config.attention_head_dim // 2
    self.unet.set_attention_slice(UpperCAmelCase__	)


 def 					_lowercase (			self							:			List[str]	):
    self.enable_attention_slicing(UpperCAmelCase__	)


 @torch.no_grad()
 def 					_lowercase (			self							:			Optional[Any],					UpperCAmelCase__							:			Union[str, List[str]],					UpperCAmelCase__							:			int = 5_1_2,					UpperCAmelCase__							:			int = 5_1_2,					UpperCAmelCase__							:			int = 5_0,					UpperCAmelCase__							:			float = 7.5,					UpperCAmelCase__							:			Optional[Union[str, List[str]]] = None,					UpperCAmelCase__							:			Optional[int] = 1,					UpperCAmelCase__							:			float = 0.0,					UpperCAmelCase__							:			Optional[torch.Generator] = None,					UpperCAmelCase__							:			Optional[torch.FloatTensor] = None,					UpperCAmelCase__							:			Optional[str] = "pil",					UpperCAmelCase__							:			bool = True,					UpperCAmelCase__							:			Optional[Callable[[int, int, torch.FloatTensor], None]] = None,					UpperCAmelCase__							:			int = 1,					**UpperCAmelCase__							:			Tuple,					):
    return self.pipea(
        prompt=UpperCAmelCase__,					height=UpperCAmelCase__,					width=UpperCAmelCase__,					num_inference_steps=UpperCAmelCase__,					guidance_scale=UpperCAmelCase__,					negative_prompt=UpperCAmelCase__,					num_images_per_prompt=UpperCAmelCase__,					eta=UpperCAmelCase__,					generator=UpperCAmelCase__,					latents=UpperCAmelCase__,					output_type=UpperCAmelCase__,					return_dict=UpperCAmelCase__,					callback=UpperCAmelCase__,					callback_steps=UpperCAmelCase__,					**UpperCAmelCase__,					)


 @torch.no_grad()
 def 					_lowercase (			self							:			Tuple,					UpperCAmelCase__							:			Union[str, List[str]],					UpperCAmelCase__							:			int = 5_1_2,					UpperCAmelCase__							:			int = 5_1_2,					UpperCAmelCase__							:			int = 5_0,					UpperCAmelCase__							:			float = 7.5,					UpperCAmelCase__							:			Optional[Union[str, List[str]]] = None,					UpperCAmelCase__							:			Optional[int] = 1,					UpperCAmelCase__							:			float = 0.0,					UpperCAmelCase__							:			Optional[torch.Generator] = None,					UpperCAmelCase__							:			Optional[torch.FloatTensor] = None,					UpperCAmelCase__							:			Optional[str] = "pil",					UpperCAmelCase__							:			bool = True,					UpperCAmelCase__							:			Optional[Callable[[int, int, torch.FloatTensor], None]] = None,					UpperCAmelCase__							:			int = 1,					**UpperCAmelCase__							:			str,					):
    return self.pipea(
        prompt=UpperCAmelCase__,					height=UpperCAmelCase__,					width=UpperCAmelCase__,					num_inference_steps=UpperCAmelCase__,					guidance_scale=UpperCAmelCase__,					negative_prompt=UpperCAmelCase__,					num_images_per_prompt=UpperCAmelCase__,					eta=UpperCAmelCase__,					generator=UpperCAmelCase__,					latents=UpperCAmelCase__,					output_type=UpperCAmelCase__,					return_dict=UpperCAmelCase__,					callback=UpperCAmelCase__,					callback_steps=UpperCAmelCase__,					**UpperCAmelCase__,					)


 @torch.no_grad()
 def 					_lowercase (			self							:			str,					UpperCAmelCase__							:			Union[str, List[str]],					UpperCAmelCase__							:			int = 5_1_2,					UpperCAmelCase__							:			int = 5_1_2,					UpperCAmelCase__							:			int = 5_0,					UpperCAmelCase__							:			float = 7.5,					UpperCAmelCase__							:			Optional[Union[str, List[str]]] = None,					UpperCAmelCase__							:			Optional[int] = 1,					UpperCAmelCase__							:			float = 0.0,					UpperCAmelCase__							:			Optional[torch.Generator] = None,					UpperCAmelCase__							:			Optional[torch.FloatTensor] = None,					UpperCAmelCase__							:			Optional[str] = "pil",					UpperCAmelCase__							:			bool = True,					UpperCAmelCase__							:			Optional[Callable[[int, int, torch.FloatTensor], None]] = None,					UpperCAmelCase__							:			int = 1,					**UpperCAmelCase__							:			Any,					):
    return self.pipea(
        prompt=UpperCAmelCase__,					height=UpperCAmelCase__,					width=UpperCAmelCase__,					num_inference_steps=UpperCAmelCase__,					guidance_scale=UpperCAmelCase__,					negative_prompt=UpperCAmelCase__,					num_images_per_prompt=UpperCAmelCase__,					eta=UpperCAmelCase__,					generator=UpperCAmelCase__,					latents=UpperCAmelCase__,					output_type=UpperCAmelCase__,					return_dict=UpperCAmelCase__,					callback=UpperCAmelCase__,					callback_steps=UpperCAmelCase__,					**UpperCAmelCase__,					)


 @torch.no_grad()
 def 					_lowercase (			self							:			Union[str, Any],					UpperCAmelCase__							:			Union[str, List[str]],					UpperCAmelCase__							:			int = 5_1_2,					UpperCAmelCase__							:			int = 5_1_2,					UpperCAmelCase__							:			int = 5_0,					UpperCAmelCase__							:			float = 7.5,					UpperCAmelCase__							:			Optional[Union[str, List[str]]] = None,					UpperCAmelCase__							:			Optional[int] = 1,					UpperCAmelCase__							:			float = 0.0,					UpperCAmelCase__							:			Optional[torch.Generator] = None,					UpperCAmelCase__							:			Optional[torch.FloatTensor] = None,					UpperCAmelCase__							:			Optional[str] = "pil",					UpperCAmelCase__							:			bool = True,					UpperCAmelCase__							:			Optional[Callable[[int, int, torch.FloatTensor], None]] = None,					UpperCAmelCase__							:			int = 1,					**UpperCAmelCase__							:			Optional[int],					):
    return self.pipea(
        prompt=UpperCAmelCase__,					height=UpperCAmelCase__,					width=UpperCAmelCase__,					num_inference_steps=UpperCAmelCase__,					guidance_scale=UpperCAmelCase__,					negative_prompt=UpperCAmelCase__,					num_images_per_prompt=UpperCAmelCase__,					eta=UpperCAmelCase__,					generator=UpperCAmelCase__,					latents=UpperCAmelCase__,					output_type=UpperCAmelCase__,					return_dict=UpperCAmelCase__,					callback=UpperCAmelCase__,					callback_steps=UpperCAmelCase__,					**UpperCAmelCase__,					)



 @torch.no_grad()
 def 					_lowercase (			self							:			Optional[Any],					UpperCAmelCase__							:			Union[str, List[str]],					UpperCAmelCase__							:			int = 5_1_2,					UpperCAmelCase__							:			int = 5_1_2,					UpperCAmelCase__							:			int = 5_0,					UpperCAmelCase__							:			float = 7.5,					UpperCAmelCase__							:			Optional[Union[str, List[str]]] = None,					UpperCAmelCase__							:			Optional[int] = 1,					UpperCAmelCase__							:			float = 0.0,					UpperCAmelCase__							:			Optional[torch.Generator] = None,					UpperCAmelCase__							:			Optional[torch.FloatTensor] = None,					UpperCAmelCase__							:			Optional[str] = "pil",					UpperCAmelCase__							:			bool = True,					UpperCAmelCase__							:			Optional[Callable[[int, int, torch.FloatTensor], None]] = None,					UpperCAmelCase__							:			int = 1,					**UpperCAmelCase__							:			str,					):
    __lowercase								=						"cuda" if torch.cuda.is_available() else "cpu"
    self.to(UpperCAmelCase__	)

    # Checks if the height and width are divisible by 8 or not
    if height % 8 != 0 or width % 8 != 0:
       raise ValueError(F"""`height` and `width` must be divisible by 8 but are {height} and {width}."""	)

    # Get first result from Stable Diffusion Checkpoint v1.1
    __lowercase								=						self.textaimg_sda_a(
        prompt=UpperCAmelCase__,					height=UpperCAmelCase__,					width=UpperCAmelCase__,					num_inference_steps=UpperCAmelCase__,					guidance_scale=UpperCAmelCase__,					negative_prompt=UpperCAmelCase__,					num_images_per_prompt=UpperCAmelCase__,					eta=UpperCAmelCase__,					generator=UpperCAmelCase__,					latents=UpperCAmelCase__,					output_type=UpperCAmelCase__,					return_dict=UpperCAmelCase__,					callback=UpperCAmelCase__,					callback_steps=UpperCAmelCase__,					**UpperCAmelCase__,					)

    # Get first result from Stable Diffusion Checkpoint v1.2
    __lowercase								=						self.textaimg_sda_a(
        prompt=UpperCAmelCase__,					height=UpperCAmelCase__,					width=UpperCAmelCase__,					num_inference_steps=UpperCAmelCase__,					guidance_scale=UpperCAmelCase__,					negative_prompt=UpperCAmelCase__,					num_images_per_prompt=UpperCAmelCase__,					eta=UpperCAmelCase__,					generator=UpperCAmelCase__,					latents=UpperCAmelCase__,					output_type=UpperCAmelCase__,					return_dict=UpperCAmelCase__,					callback=UpperCAmelCase__,					callback_steps=UpperCAmelCase__,					**UpperCAmelCase__,					)

    # Get first result from Stable Diffusion Checkpoint v1.3
    __lowercase								=						self.textaimg_sda_a(
        prompt=UpperCAmelCase__,					height=UpperCAmelCase__,					width=UpperCAmelCase__,					num_inference_steps=UpperCAmelCase__,					guidance_scale=UpperCAmelCase__,					negative_prompt=UpperCAmelCase__,					num_images_per_prompt=UpperCAmelCase__,					eta=UpperCAmelCase__,					generator=UpperCAmelCase__,					latents=UpperCAmelCase__,					output_type=UpperCAmelCase__,					return_dict=UpperCAmelCase__,					callback=UpperCAmelCase__,					callback_steps=UpperCAmelCase__,					**UpperCAmelCase__,					)

    # Get first result from Stable Diffusion Checkpoint v1.4
    __lowercase								=						self.textaimg_sda_a(
        prompt=UpperCAmelCase__,					height=UpperCAmelCase__,					width=UpperCAmelCase__,					num_inference_steps=UpperCAmelCase__,					guidance_scale=UpperCAmelCase__,					negative_prompt=UpperCAmelCase__,					num_images_per_prompt=UpperCAmelCase__,					eta=UpperCAmelCase__,					generator=UpperCAmelCase__,					latents=UpperCAmelCase__,					output_type=UpperCAmelCase__,					return_dict=UpperCAmelCase__,					callback=UpperCAmelCase__,					callback_steps=UpperCAmelCase__,					**UpperCAmelCase__,					)

    # Get all result images into a single list and pass it via StableDiffusionPipelineOutput for final result
    return StableDiffusionPipelineOutput([resa[0], resa[0], resa[0], resa[0]]	)




