



'''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


a							   =				False






@skip_mps
class 						a_		(     SCREAMING_SNAKE_CASE_    ,   SCREAMING_SNAKE_CASE_    ,   SCREAMING_SNAKE_CASE_    ,   unittest.TestCase    ):
							UpperCAmelCase			:		Union[str, Any]        =				StableDiffusionAttendAndExcitePipeline
							UpperCAmelCase			:		Dict        =				False
							UpperCAmelCase			:		List[str]        =				TEXT_TO_IMAGE_PARAMS
							UpperCAmelCase			:		Optional[Any]        =				TEXT_TO_IMAGE_BATCH_PARAMS.union({"""token_indices"""}    )
							UpperCAmelCase			:		str        =				TEXT_TO_IMAGE_IMAGE_PARAMS
							UpperCAmelCase			:		Optional[Any]        =				TEXT_TO_IMAGE_IMAGE_PARAMS


							@classmethod
							def    UpperCamelCase     (				cls   :						Any			)			->					Union[str, Any]:
										super().setUpClass()
										torch.use_deterministic_algorithms(__a			)


							@classmethod
							def    UpperCamelCase     (				cls   :						List[str]			)			->					Optional[Any]:
										super().tearDownClass()
										torch.use_deterministic_algorithms(__a			)


							def    UpperCamelCase     (				self   :						Dict			)			->					Optional[Any]:
										torch.manual_seed(0			)
										snake_case:    Tuple      							=UNetaDConditionModel(
										    block_out_channels=(3_2, 6_4)      ,						layers_per_block=1      ,						sample_size=3_2      ,						in_channels=4      ,						out_channels=4      ,						down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')      ,						up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D')      ,						cross_attention_dim=3_2      ,						attention_head_dim=(2, 4)      ,						use_linear_projection=__a      ,						)
										snake_case:    str      							=DDIMScheduler(
										    beta_start=0.0_0_0_8_5      ,						beta_end=0.0_1_2      ,						beta_schedule='scaled_linear'      ,						clip_sample=__a      ,						set_alpha_to_one=__a      ,						)
										torch.manual_seed(0			)
										snake_case:    List[str]      							=AutoencoderKL(
										    block_out_channels=[3_2, 6_4]      ,						in_channels=3      ,						out_channels=3      ,						down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D']      ,						up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D']      ,						latent_channels=4      ,						sample_size=1_2_8      ,						)
										torch.manual_seed(0			)
										snake_case:    Optional[int]      							=CLIPTextConfig(
										    bos_token_id=0      ,						eos_token_id=2      ,						hidden_size=3_2      ,						intermediate_size=3_7      ,						layer_norm_eps=1E-0_5      ,						num_attention_heads=4      ,						num_hidden_layers=5      ,						pad_token_id=1      ,						vocab_size=1_0_0_0      ,						hidden_act='gelu'      ,						projection_dim=5_1_2      ,						)
										snake_case:    str      							=CLIPTextModel(__a			)
										snake_case:    Dict      							=CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'			)

										snake_case:    Union[str, Any]      							={
										    'unet': unet,
										    'scheduler': scheduler,
										    'vae': vae,
										    'text_encoder': text_encoder,
										    'tokenizer': tokenizer,
										    'safety_checker': None,
										    'feature_extractor': None,
										}

										return components


							def    UpperCamelCase     (				self   :						Optional[int]      ,						a_   :						Tuple      ,						a_   :						Dict=0			)			->					List[str]:
										if str(__a			).startswith('mps'			):
													snake_case:    Optional[Any]      							=torch.manual_seed(__a			)
										else:
													snake_case:    int      							=torch.Generator(device=__a			).manual_seed(__a			)
										snake_case:    Union[str, 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    UpperCamelCase     (				self   :						Optional[int]			)			->					List[Any]:
										snake_case:    int      							='cpu'

										snake_case:    int      							=self.get_dummy_components()
										snake_case:    Optional[int]      							=self.pipeline_class(**__a			)
										pipe.to(__a			)
										pipe.set_progress_bar_config(disable=__a			)

										snake_case:    List[Any]      							=self.get_dummy_inputs(__a			)
										snake_case:    Tuple      							=pipe(**__a			).images
										snake_case:    int      							=image[0, -3:, -3:, -1]

										self.assertEqual(image.shape      ,						(1, 6_4, 6_4, 3)			)
										snake_case:    Dict      							=np.array(
										    [0.6_3_9_0_5_3_6_4, 0.6_2_8_9_7_3_0_7, 0.4_8_5_9_9_0_1_7, 0.5_1_3_3_6_2_4, 0.5_5_5_0_0_4_8, 0.4_5_7_6_9_5_1_6, 0.5_0_3_2_6_9_7_3, 0.5_0_2_3_1_3_9, 0.4_5_3_8_4_4_9_6]			)
										snake_case:    Tuple      							=np.abs(image_slice.flatten() - expected_slice			).max()
										self.assertLessEqual(__a      ,						1E-3			)


							def    UpperCamelCase     (				self   :						Tuple			)			->					List[Any]:
										super().test_cpu_offload_forward_pass(expected_max_diff=5E-4			)


							def    UpperCamelCase     (				self   :						List[Any]			)			->					str:
										self._test_inference_batch_consistent(batch_sizes=[1, 2]			)


							def    UpperCamelCase     (				self   :						List[Any]			)			->					Any:
										self._test_inference_batch_single_identical(batch_size=2      ,						expected_max_diff=7E-4			)


							def    UpperCamelCase     (				self   :						Union[str, Any]			)			->					Dict:
										super().test_dict_tuple_outputs_equivalent(expected_max_difference=3E-3			)


							def    UpperCamelCase     (				self   :						Any			)			->					Union[str, Any]:
										super().test_pt_np_pil_outputs_equivalent(expected_max_diff=5E-4			)


							def    UpperCamelCase     (				self   :						Dict			)			->					Dict:
										super().test_save_load_local(expected_max_difference=5E-4			)




							def    UpperCamelCase     (				self   :						Optional[Any]			)			->					int:
										super().test_save_load_optional_components(expected_max_difference=4E-4			)






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


							@classmethod
							def    UpperCamelCase     (				cls   :						Tuple			)			->					Optional[int]:
										super().setUpClass()
										torch.use_deterministic_algorithms(__a			)


							@classmethod
							def    UpperCamelCase     (				cls   :						Optional[Any]			)			->					str:
										super().tearDownClass()
										torch.use_deterministic_algorithms(__a			)


							def    UpperCamelCase     (				self   :						Any			)			->					List[str]:
										super().tearDown()
										gc.collect()
										torch.cuda.empty_cache()




							def    UpperCamelCase     (				self   :						Union[str, Any]			)			->					Optional[Any]:
										snake_case:    Union[str, Any]      							=torch.manual_seed(5_1			)

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

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

										snake_case:    Dict      							=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]

										snake_case:    List[Any]      							=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'''





from abc import ABC, abstractmethod
from argparse import ArgumentParser



class  snake_case__						(    SCREAMING_SNAKE_CASE_				):
 @staticmethod
 @abstractmethod
 def A_   (   __a						:							ArgumentParser  )      ->   List[str]:







       '''simple docstring'''
       raise NotImplementedError()





 @abstractmethod
 def A_   (   self						:							Optional[Any]  )      ->   Optional[Any]:







       '''simple docstring'''
       raise NotImplementedError()



