
'''simple docstring'''







import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    StableDiffusionAttendAndExcitePipeline,
    UNetaDConditionModel,
)
from diffusers.utils import load_numpy, skip_mps, slow
from diffusers.utils.testing_utils import 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 PipelineKarrasSchedulerTesterMixin, PipelineLatentTesterMixin, PipelineTesterMixin


__lowerCAmelCase         =    False







@skip_mps
class UpperCAmelCase__	( lowercase__    ,				lowercase__    ,				lowercase__    ,				unittest.TestCase	):





  """simple docstring"""

  __UpperCAmelCase				:				List[str]   =					StableDiffusionAttendAndExcitePipeline
  __UpperCAmelCase				:				Optional[Any]   =					False
  __UpperCAmelCase				:				Optional[int]   =					TEXT_TO_IMAGE_PARAMS
  __UpperCAmelCase				:				int   =					TEXT_TO_IMAGE_BATCH_PARAMS.union({'''token_indices'''}	)
  __UpperCAmelCase				:				Any   =					TEXT_TO_IMAGE_IMAGE_PARAMS
  __UpperCAmelCase				:				Dict   =					TEXT_TO_IMAGE_IMAGE_PARAMS


  @classmethod
  def   __lowercase		(		cls      :     Optional[int]       ):


     '''simple docstring'''






     super().setUpClass()
     torch.use_deterministic_algorithms(_a       )


  @classmethod
  def   __lowercase		(		cls      :     Tuple       ):


     '''simple docstring'''






     super().tearDownClass()
     torch.use_deterministic_algorithms(_a       )


  def   __lowercase		(		self      :     str       ):


     '''simple docstring'''






     torch.manual_seed(0       )
     _a				:	Union[str, Any]			=   UNetaDConditionModel(
         block_out_channels=(32, 64)							,layers_per_block=1							,sample_size=32							,in_channels=4							,out_channels=4							,down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')							,up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D')							,cross_attention_dim=32							,attention_head_dim=(2, 4)							,use_linear_projection=_a							,)
     _a				:	List[Any]			=   DDIMScheduler(
         beta_start=0.0_0085							,beta_end=0.012							,beta_schedule='scaled_linear'							,clip_sample=_a							,set_alpha_to_one=_a							,)
     torch.manual_seed(0       )
     _a				:	str			=   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							,sample_size=128							,)
     torch.manual_seed(0       )
     _a				:	Optional[int]			=   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=1000							,hidden_act='gelu'							,projection_dim=512							,)
     _a				:	int			=   CLIPTextModel(_a       )
     _a				:	Optional[Any]			=   CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'       )

     _a				:	Tuple			=   {
         'unet': unet,
         'scheduler': scheduler,
         'vae': vae,
         'text_encoder': text_encoder,
         'tokenizer': tokenizer,
         'safety_checker': None,
         'feature_extractor': None,
     }

     return components


  def   __lowercase		(		self      :     Optional[Any]							,_a      :     str							,_a      :     Union[str, Any]=0       ):


     '''simple docstring'''






     if str(_a       ).startswith('mps'       ):
        _a				:	List[str]			=   torch.manual_seed(_a       )
     else:
        _a				:	str			=   torch.Generator(device=_a       ).manual_seed(_a       )
     _a				:	Any			=   {
         'prompt': 'a cat and a frog',
         'token_indices': [2, 5],
         'generator': generator,
         'num_inference_steps': 1,
         'guidance_scale': 6.0,
         'output_type': 'numpy',
         'max_iter_to_alter': 2,
         'thresholds': {0: 0.7},
     }
     return inputs


  def   __lowercase		(		self      :     List[str]       ):


     '''simple docstring'''






     _a				:	Any			=   'cpu'

     _a				:	Dict			=   self.get_dummy_components()
     _a				:	Tuple			=   self.pipeline_class(**_a       )
     pipe.to(_a       )
     pipe.set_progress_bar_config(disable=_a       )

     _a				:	List[str]			=   self.get_dummy_inputs(_a       )
     _a				:	Tuple			=   pipe(**_a       ).images
     _a				:	Union[str, Any]			=   image[0, -3:, -3:, -1]

     self.assertEqual(image.shape							,(1, 64, 64, 3)       )
     _a				:	List[str]			=   np.array(
         [0.6390_5364, 0.6289_7307, 0.4859_9017, 0.513_3624, 0.555_0048, 0.4576_9516, 0.5032_6973, 0.502_3139, 0.4538_4496]       )
     _a				:	List[Any]			=   np.abs(image_slice.flatten() - expected_slice       ).max()
     self.assertLessEqual(_a							,1E-3       )


  def   __lowercase		(		self      :     Optional[Any]       ):


     '''simple docstring'''






     super().test_cpu_offload_forward_pass(expected_max_diff=5E-4       )


  def   __lowercase		(		self      :     Optional[int]       ):


     '''simple docstring'''






     self._test_inference_batch_consistent(batch_sizes=[1, 2]       )


  def   __lowercase		(		self      :     List[str]       ):


     '''simple docstring'''






     self._test_inference_batch_single_identical(batch_size=2							,expected_max_diff=7E-4       )


  def   __lowercase		(		self      :     Optional[Any]       ):


     '''simple docstring'''






     super().test_dict_tuple_outputs_equivalent(expected_max_difference=3E-3       )


  def   __lowercase		(		self      :     int       ):


     '''simple docstring'''






     super().test_pt_np_pil_outputs_equivalent(expected_max_diff=5E-4       )


  def   __lowercase		(		self      :     int       ):


     '''simple docstring'''






     super().test_save_load_local(expected_max_difference=5E-4       )


  def   __lowercase		(		self      :     Optional[Any]       ):


     '''simple docstring'''






     super().test_save_load_optional_components(expected_max_difference=4E-4       )







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





  """simple docstring"""

  @classmethod
  def   __lowercase		(		cls      :     List[str]       ):


     '''simple docstring'''






     super().setUpClass()
     torch.use_deterministic_algorithms(_a       )


  @classmethod
  def   __lowercase		(		cls      :     List[Any]       ):


     '''simple docstring'''






     super().tearDownClass()
     torch.use_deterministic_algorithms(_a       )


  def   __lowercase		(		self      :     Optional[int]       ):


     '''simple docstring'''






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


  def   __lowercase		(		self      :     Optional[Any]       ):


     '''simple docstring'''






     _a				:	Tuple			=   torch.manual_seed(51       )

     _a				:	str			=   StableDiffusionAttendAndExcitePipeline.from_pretrained(
         'CompVis/stable-diffusion-v1-4'							,safety_checker=_a							,torch_dtype=torch.floataa       )
     pipe.to('cuda'       )

     _a				:	Any			=   'a painting of an elephant with glasses'
     _a				:	List[str]			=   [5, 7]

     _a				:	List[Any]			=   pipe(
         prompt=_a							,token_indices=_a							,guidance_scale=7.5							,generator=_a							,num_inference_steps=5							,max_iter_to_alter=5							,output_type='numpy'							,).images[0]

     _a				:	Dict			=   load_numpy(
         'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/attend-and-excite/elephant_glasses.npy'       )
     assert np.abs((expected_image - image).max()       ) < 5E-1





'''simple docstring'''







class UpperCAmelCase__	:





  """simple docstring"""

  def __init__(		self      :     Dict       ):


     '''simple docstring'''






     _a				:	Dict			=   {}


  def   __lowercase		(		self      :     Union[str, Any]       ):


     '''simple docstring'''






     print(self.vertex       )
     for i in self.vertex:
        print(_a							,' -> '							,' -> '.join([str(_a       ) for j in self.vertex[i]]       )       )


  def   __lowercase		(		self      :     Dict							,_a      :     int							,_a      :     int       ):


     '''simple docstring'''






     if from_vertex in self.vertex:
        self.vertex[from_vertex].append(_a       )
     else:
        # else make a new vertex
        _a				:	int			=   [to_vertex]


  def   __lowercase		(		self      :     Optional[int]       ):


     '''simple docstring'''






     _a				:	Tuple			=   [False] * len(self.vertex       )

     # call the recursive helper function
     for i in range(len(self.vertex       )       ):
        if not visited[i]:
           self.dfs_recursive(_a							,_a       )


  def   __lowercase		(		self      :     Union[str, Any]							,_a      :     int							,_a      :     list       ):


     '''simple docstring'''






     _a				:	List[Any]			=   True

     print(_a							,end=' '       )

     # Recur for all the vertices that are adjacent to this node
     for i in self.vertex:
        if not visited[i]:
           self.dfs_recursive(_a							,_a       )


if __name__ == "__main__":
  __lowerCAmelCase         =    Graph()
  g.add_edge(0, 1)
  g.add_edge(0, 2)
  g.add_edge(1, 2)
  g.add_edge(2, 0)
  g.add_edge(2, 3)
  g.add_edge(3, 3)

  g.print_graph()
  print("""DFS:""")
  g.dfs()

  # OUTPUT:
  # 0  ->  1 -> 2
  # 1  ->  2
  # 2  ->  0 -> 3
  # 3  ->  3
  # DFS:
  #  0 1 2 3



