




'''simple docstring'''







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 			_a  (	__a							,							__a							,							unittest.TestCase ):
       __a				:     str   				=					StableDiffusionSAGPipeline
       __a				:     List[Any]   				=					TEXT_TO_IMAGE_PARAMS
       __a				:     Dict   				=					TEXT_TO_IMAGE_BATCH_PARAMS
       __a				:     Optional[Any]   				=					TEXT_TO_IMAGE_IMAGE_PARAMS
       __a				:     Tuple   				=					TEXT_TO_IMAGE_IMAGE_PARAMS
       __a				:     int   				=					False
       def     A      (	self						:	Optional[int]				):



           '''simple docstring'''

           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.0_0085   ,				beta_end=0.012   ,				beta_schedule='''scaled_linear'''   ,				clip_sample=lowercase   ,				set_alpha_to_one=lowercase   ,				)
           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-05   ,				num_attention_heads=4   ,				num_hidden_layers=5   ,				pad_token_id=1   ,				vocab_size=1_000   ,				)
           UpperCAmelCase			       =		CLIPTextModel(lowercase				)
           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						:	List[str]   ,				lowercase						:	Dict   ,				lowercase						:	Optional[int]=0				):



           '''simple docstring'''

           if str(lowercase				).startswith('''mps'''				):
               UpperCAmelCase			       =		torch.manual_seed(lowercase				)
           else:
               UpperCAmelCase			       =		torch.Generator(device=lowercase				).manual_seed(lowercase				)
           UpperCAmelCase			       =		{
               '''prompt''': '''.''',
               '''generator''': generator,
               '''num_inference_steps''': 2,
               '''guidance_scale''': 1.0,
               '''sag_scale''': 1.0,
               '''output_type''': '''numpy''',
           }
           return inputs







       def     A      (	self						:	List[str]				):



           '''simple docstring'''

           super().test_inference_batch_single_identical(expected_max_diff=3E-3				)






@slow
@require_torch_gpu
class 			_a  (	unittest.TestCase ):
       def     A      (	self						:	Any				):



           '''simple docstring'''

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



           '''simple docstring'''

           UpperCAmelCase			       =		StableDiffusionSAGPipeline.from_pretrained('''CompVis/stable-diffusion-v1-4'''				)
           UpperCAmelCase			       =		sag_pipe.to(lowercase				)
           sag_pipe.set_progress_bar_config(disable=lowercase				)

           UpperCAmelCase			       =		'''.'''
           UpperCAmelCase			       =		torch.manual_seed(0				)
           UpperCAmelCase			       =		sag_pipe(
               [prompt]   ,				generator=lowercase   ,				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						:	Dict				):



           '''simple docstring'''

           UpperCAmelCase			       =		StableDiffusionSAGPipeline.from_pretrained('''stabilityai/stable-diffusion-2-1-base'''				)
           UpperCAmelCase			       =		sag_pipe.to(lowercase				)
           sag_pipe.set_progress_bar_config(disable=lowercase				)

           UpperCAmelCase			       =		'''.'''
           UpperCAmelCase			       =		torch.manual_seed(0				)
           UpperCAmelCase			       =		sag_pipe(
               [prompt]   ,				generator=lowercase   ,				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						:	Tuple				):



           '''simple docstring'''

           UpperCAmelCase			       =		StableDiffusionSAGPipeline.from_pretrained('''stabilityai/stable-diffusion-2-1-base'''				)
           UpperCAmelCase			       =		sag_pipe.to(lowercase				)
           sag_pipe.set_progress_bar_config(disable=lowercase				)

           UpperCAmelCase			       =		'''.'''
           UpperCAmelCase			       =		torch.manual_seed(0				)
           UpperCAmelCase			       =		sag_pipe(
               [prompt]   ,				width=768   ,				height=512   ,				generator=lowercase   ,				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)










'''simple docstring'''







from queue import PriorityQueue
from typing import Any

import numpy as np





def 						snake_case_							(_a	:							dict    ,   _a	:							str    ,   _a	:							set    ,   _a	:							set    ,   _a	:							dict    ,   _a	:							dict    ,   _a	:							PriorityQueue    ,   _a	:							dict    ,   _a	:							float | int    ,   ):
    for nxt, d in graph[v]:
        if nxt in visited_forward:
            continue
        UpperCAmelCase			       =		cst_fwd.get(_a    ,   np.inf     )
        UpperCAmelCase			       =		cst_fwd[v] + d
        if new_cost_f < old_cost_f:
            queue.put((new_cost_f, nxt)     )
            UpperCAmelCase			       =		new_cost_f
            UpperCAmelCase			       =		v
        if nxt in visited_backward:
            if cst_fwd[v] + d + cst_bwd[nxt] < shortest_distance:
                UpperCAmelCase			       =		cst_fwd[v] + d + cst_bwd[nxt]
    return shortest_distance





def 						snake_case_							(_a	:							str    ,   _a	:							str    ,   _a	:							dict    ,   _a	:							dict     ):
    UpperCAmelCase			       =		-1

    UpperCAmelCase			       =		set()
    UpperCAmelCase			       =		set()
    UpperCAmelCase			       =		{source: 0}
    UpperCAmelCase			       =		{destination: 0}
    UpperCAmelCase			       =		{source: None}
    UpperCAmelCase			       =		{destination: None}
    UpperCAmelCase			       =		PriorityQueue()
    UpperCAmelCase			       =		PriorityQueue()

    UpperCAmelCase			       =		np.inf

    queue_forward.put((0, source)     )
    queue_backward.put((0, destination)     )

    if source == destination:
        return 0

    while not queue_forward.empty() and not queue_backward.empty():
        UpperCAmelCase       ,     UpperCAmelCase			       =		queue_forward.get()
        visited_forward.add(_a     )

        UpperCAmelCase       ,     UpperCAmelCase			       =		queue_backward.get()
        visited_backward.add(_a     )

        UpperCAmelCase			       =		pass_and_relaxation(
            _a    ,   _a    ,   _a    ,   _a    ,   _a    ,   _a    ,   _a    ,   _a    ,   _a    ,   )

        UpperCAmelCase			       =		pass_and_relaxation(
            _a    ,   _a    ,   _a    ,   _a    ,   _a    ,   _a    ,   _a    ,   _a    ,   _a    ,   )

        if cst_fwd[v_fwd] + cst_bwd[v_bwd] >= shortest_distance:
            break

    if shortest_distance != np.inf:
        UpperCAmelCase			       =		shortest_distance
    return shortest_path_distance


A     ={
    'B': [['C', 1]],
    'C': [['D', 1]],
    'D': [['F', 1]],
    'E': [['B', 1], ['G', 2]],
    'F': [],
    'G': [['F', 1]],
}
A     ={
    'B': [['E', 1]],
    'C': [['B', 1]],
    'D': [['C', 1]],
    'F': [['D', 1], ['G', 1]],
    'E': [[None, np.inf]],
    'G': [['E', 2]],
}

if __name__ == "__main__":
   import doctest

   doctest.testmod()




