




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


_lowercase  =			False
@skip_mps
class 						a_				(			UpperCAmelCase__     ,						UpperCAmelCase__     ,						UpperCAmelCase__     ,						unittest.TestCase						):
	lowercase_       :     Any			  =      StableDiffusionAttendAndExcitePipeline
	lowercase_       :     Dict			  =      False
	lowercase_       :     Dict			  =      TEXT_TO_IMAGE_PARAMS
	lowercase_       :     Dict			  =      TEXT_TO_IMAGE_BATCH_PARAMS.union({'''token_indices'''}						)
	lowercase_       :     Optional[int]			  =      TEXT_TO_IMAGE_IMAGE_PARAMS
	lowercase_       :     Optional[int]			  =      TEXT_TO_IMAGE_IMAGE_PARAMS




	@classmethod
	def   lowercase__   (       cls     :  Optional[int]      ):
							super().setUpClass()
							torch.use_deterministic_algorithms(__lowerCAmelCase      )




	@classmethod
	def   lowercase__   (       cls     :  Optional[int]      ):
							super().tearDownClass()
							torch.use_deterministic_algorithms(__lowerCAmelCase      )




	def   lowercase__   (       self     :  Any      ):
							torch.manual_seed(0      )
							__snake_case						 =   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=__lowerCAmelCase       ,		)
							__snake_case						 =   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      )
							__snake_case						 =   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						 =   CLIPTextConfig(
							    bos_token_id=0       ,		eos_token_id=2       ,		hidden_size=3_2       ,		intermediate_size=3_7       ,		layer_norm_eps=1E-05       ,		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						 =   CLIPTextModel(__lowerCAmelCase      )
							__snake_case						 =   CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'      )

							__snake_case						 =   {
							    '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]       ,		__lowerCAmelCase     :  Dict       ,		__lowerCAmelCase     :  Dict=0      ):
							if str(__lowerCAmelCase      ).startswith('mps'      ):
													__snake_case						 =   torch.manual_seed(__lowerCAmelCase      )
							else:
													__snake_case						 =   torch.Generator(device=__lowerCAmelCase      ).manual_seed(__lowerCAmelCase      )
							__snake_case						 =   __snake_case						 =   {
							    '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     :  Union[str, Any]      ):
							__snake_case						 =   'cpu'

							__snake_case						 =   self.get_dummy_components()
							__snake_case						 =   self.pipeline_class(**__lowerCAmelCase      )
							pipe.to(__lowerCAmelCase      )
							pipe.set_progress_bar_config(disable=__lowerCAmelCase      )

							__snake_case						 =   self.get_dummy_inputs(__lowerCAmelCase      )
							__snake_case						 =   pipe(**__lowerCAmelCase      ).images
							__snake_case						 =   image[0, -3:, -3:, -1]

							self.assertEqual(image.shape       ,		(1, 6_4, 6_4, 3)      )
							__snake_case						 =   np.array(
							    [0.63905364, 0.62897307, 0.48599017, 0.5133624, 0.5550048, 0.45769516, 0.50326973, 0.5023139, 0.45384496]      )
							__snake_case						 =   np.abs(image_slice.flatten() - expected_slice      ).max()
							self.assertLessEqual(__lowerCAmelCase       ,		1E-3      )




	def   lowercase__   (       self     :  Union[str, Any]      ):
							super().test_cpu_offload_forward_pass(expected_max_diff=5E-4      )




	def   lowercase__   (       self     :  List[Any]      ):
							# NOTE: Larger batch sizes cause this test to timeout, only test on smaller batches
							self._test_inference_batch_consistent(batch_sizes=[1, 2]      )




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




	def   lowercase__   (       self     :  int      ):
							super().test_dict_tuple_outputs_equivalent(expected_max_difference=3E-3      )




	def   lowercase__   (       self     :  Any      ):
							super().test_pt_np_pil_outputs_equivalent(expected_max_diff=5E-4      )




	def   lowercase__   (       self     :  List[str]      ):
							super().test_save_load_local(expected_max_difference=5E-4      )




	def   lowercase__   (       self     :  Any      ):
							super().test_save_load_optional_components(expected_max_difference=4E-4      )





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




	@classmethod
	def   lowercase__   (       cls     :  Optional[int]      ):
							super().setUpClass()
							torch.use_deterministic_algorithms(__lowerCAmelCase      )




	@classmethod
	def   lowercase__   (       cls     :  Optional[int]      ):
							super().tearDownClass()
							torch.use_deterministic_algorithms(__lowerCAmelCase      )




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




	def   lowercase__   (       self     :  Optional[Any]      ):
							__snake_case						 =   torch.manual_seed(5_1      )

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

							__snake_case						 =   'a painting of an elephant with glasses'
							__snake_case						 =   [5, 7]

							__snake_case						 =   pipe(
							    prompt=__lowerCAmelCase       ,		token_indices=__lowerCAmelCase       ,		guidance_scale=7.5       ,		generator=__lowerCAmelCase       ,		num_inference_steps=5       ,		max_iter_to_alter=5       ,		output_type='numpy'       ,		).images[0]

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


def 						lowerCamelCase__   (				a							):
						assert (
						    isinstance(a    ,	a							) and number_of_steps > 0
						), f'number_of_steps needs to be positive integer, your input {number_of_steps}'
						if number_of_steps == 1:
												return 1
						__snake_case ,       __snake_case						 =   1, 1
						for _ in range(number_of_steps - 1							):
												__snake_case ,       __snake_case						 =   current + previous, current
						return current


if __name__ == "__main__":
	import doctest

	doctest.testmod()

