



import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    StableDiffusionSAGPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()



class 	lowerCamelCase      (						lowercase__,     lowercase__,     unittest.TestCase  ):







					'''simple docstring'''







					lowerCAmelCase_				:    Any									=  StableDiffusionSAGPipeline
					lowerCAmelCase_				:    Union[str, Any]									=  TEXT_TO_IMAGE_PARAMS
					lowerCAmelCase_				:    Any									=  TEXT_TO_IMAGE_BATCH_PARAMS
					lowerCAmelCase_				:    Union[str, Any]									=  TEXT_TO_IMAGE_IMAGE_PARAMS
					lowerCAmelCase_				:    str									=  TEXT_TO_IMAGE_IMAGE_PARAMS
					lowerCAmelCase_				:    List[Any]									=  False



					def    A__		(			self     ):
							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(
							    beta_start=0.00085    ,	beta_end=0.012    ,	beta_schedule="scaled_linear"    ,	clip_sample=lowerCAmelCase    ,	set_alpha_to_one=lowerCAmelCase    ,	)
							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(lowerCAmelCase     )
							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    ,	lowerCAmelCase    ,	lowerCAmelCase=0     ):
							if str(lowerCAmelCase     ).startswith("mps"     ):
									UpperCAmelCase_						=				torch.manual_seed(lowerCAmelCase     )
							else:
									UpperCAmelCase_						=				torch.Generator(device=lowerCAmelCase     ).manual_seed(lowerCAmelCase     )
							UpperCAmelCase_						=				{
							    "prompt": ".",
							    "generator": generator,
							    "num_inference_steps": 2,
							    "guidance_scale": 1.0,
							    "sag_scale": 1.0,
							    "output_type": "numpy",
							}
							return inputs



					def    A__		(			self     ):
							super().test_inference_batch_single_identical(expected_max_diff=3e-3     )





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







					'''simple docstring'''







					def    A__		(			self     ):
							# clean up the VRAM after each test
							super().tearDown()
							gc.collect()
							torch.cuda.empty_cache()



					def    A__		(			self     ):
							UpperCAmelCase_						=				StableDiffusionSAGPipeline.from_pretrained("CompVis/stable-diffusion-v1-4"     )
							UpperCAmelCase_						=				sag_pipe.to(lowerCAmelCase     )
							sag_pipe.set_progress_bar_config(disable=lowerCAmelCase     )

							UpperCAmelCase_						=				"."
							UpperCAmelCase_						=				torch.manual_seed(0     )
							UpperCAmelCase_						=				sag_pipe(
							    [prompt]    ,	generator=lowerCAmelCase    ,	guidance_scale=7.5    ,	sag_scale=1.0    ,	num_inference_steps=20    ,	output_type="np"     )

							UpperCAmelCase_						=				output.images

							UpperCAmelCase_						=				image[0, -3:, -3:, -1]

							assert image.shape == (1, 512, 512, 3)
							UpperCAmelCase_						=				np.array([0.1568, 0.1738, 0.1695, 0.1693, 0.1507, 0.1705, 0.1547, 0.1751, 0.1949]     )

							assert np.abs(image_slice.flatten() - expected_slice     ).max() < 5e-2



					def    A__		(			self     ):
							UpperCAmelCase_						=				StableDiffusionSAGPipeline.from_pretrained("stabilityai/stable-diffusion-2-1-base"     )
							UpperCAmelCase_						=				sag_pipe.to(lowerCAmelCase     )
							sag_pipe.set_progress_bar_config(disable=lowerCAmelCase     )

							UpperCAmelCase_						=				"."
							UpperCAmelCase_						=				torch.manual_seed(0     )
							UpperCAmelCase_						=				sag_pipe(
							    [prompt]    ,	generator=lowerCAmelCase    ,	guidance_scale=7.5    ,	sag_scale=1.0    ,	num_inference_steps=20    ,	output_type="np"     )

							UpperCAmelCase_						=				output.images

							UpperCAmelCase_						=				image[0, -3:, -3:, -1]

							assert image.shape == (1, 512, 512, 3)
							UpperCAmelCase_						=				np.array([0.3459, 0.2876, 0.2537, 0.3002, 0.2671, 0.2160, 0.3026, 0.2262, 0.2371]     )

							assert np.abs(image_slice.flatten() - expected_slice     ).max() < 5e-2



					def    A__		(			self     ):
							UpperCAmelCase_						=				StableDiffusionSAGPipeline.from_pretrained("stabilityai/stable-diffusion-2-1-base"     )
							UpperCAmelCase_						=				sag_pipe.to(lowerCAmelCase     )
							sag_pipe.set_progress_bar_config(disable=lowerCAmelCase     )

							UpperCAmelCase_						=				"."
							UpperCAmelCase_						=				torch.manual_seed(0     )
							UpperCAmelCase_						=				sag_pipe(
							    [prompt]    ,	width=768    ,	height=512    ,	generator=lowerCAmelCase    ,	guidance_scale=7.5    ,	sag_scale=1.0    ,	num_inference_steps=20    ,	output_type="np"    ,	)

							UpperCAmelCase_						=				output.images

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






import heapq as hq
import math
from collections.abc import Iterator



class 	lowerCamelCase      :







					'''simple docstring'''







					def __init__(			self    ,	lowerCAmelCase     ):
							UpperCAmelCase_						=				str(id_     )
							UpperCAmelCase_						=				None
							UpperCAmelCase_						=				None
							UpperCAmelCase_						=				[]
							UpperCAmelCase_						=				{}  # {vertex:distance}



					def __lt__(			self    ,	lowerCAmelCase     ):
							return self.key < other.key



					def __repr__(			self     ):
							return self.id



					def    A__		(			self    ,	lowerCAmelCase     ):
							self.neighbors.append(lowerCAmelCase     )



					def    A__		(			self    ,	lowerCAmelCase    ,	lowerCAmelCase     ):
							UpperCAmelCase_						=				weight







def snake_case__  (			__SCREAMING_SNAKE_CASE			,     __SCREAMING_SNAKE_CASE			,     __SCREAMING_SNAKE_CASE			,     __SCREAMING_SNAKE_CASE )		->							Optional[int]:
		# add the neighbors:
		graph[a - 1].add_neighbor(graph[b - 1] )
		graph[b - 1].add_neighbor(graph[a - 1] )
		# add the edges:
		graph[a - 1].add_edge(graph[b - 1]			,     __SCREAMING_SNAKE_CASE )
		graph[b - 1].add_edge(graph[a - 1]			,     __SCREAMING_SNAKE_CASE )







def snake_case__  (			__SCREAMING_SNAKE_CASE			,     __SCREAMING_SNAKE_CASE )		->							list:
		UpperCAmelCase_						=				[]
		for u in graph:
				UpperCAmelCase_						=				math.inf
				UpperCAmelCase_						=				None
		UpperCAmelCase_						=				0
		UpperCAmelCase_						=				graph[:]
		while q:
				UpperCAmelCase_						=				min(__SCREAMING_SNAKE_CASE )
				q.remove(__SCREAMING_SNAKE_CASE )
				for v in u.neighbors:
						if (v in q) and (u.edges[v.id] < v.key):
								UpperCAmelCase_						=				u
								UpperCAmelCase_						=				u.edges[v.id]
		for i in range(1			,     len(__SCREAMING_SNAKE_CASE ) ):
				a.append((int(graph[i].id ) + 1, int(graph[i].pi.id ) + 1) )
		return a







def snake_case__  (			__SCREAMING_SNAKE_CASE			,     __SCREAMING_SNAKE_CASE )		->							Iterator[tuple]:
		for u in graph:
				UpperCAmelCase_						=				math.inf
				UpperCAmelCase_						=				None
		UpperCAmelCase_						=				0

		UpperCAmelCase_						=				list(__SCREAMING_SNAKE_CASE )
		hq.heapify(__SCREAMING_SNAKE_CASE )

		while h:
				UpperCAmelCase_						=				hq.heappop(__SCREAMING_SNAKE_CASE )
				for v in u.neighbors:
						if (v in h) and (u.edges[v.id] < v.key):
								UpperCAmelCase_						=				u
								UpperCAmelCase_						=				u.edges[v.id]
								hq.heapify(__SCREAMING_SNAKE_CASE )

		for i in range(1			,     len(__SCREAMING_SNAKE_CASE ) ):
				yield (int(graph[i].id ) + 1, int(graph[i].pi.id ) + 1)







def snake_case__  (			)		->							None:
		pass


if __name__ == "__main__":
			import doctest

			doctest.testmod()

