


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


__UpperCamelCase    		=       False







@skip_mps
class        lowerCamelCase__	(							UpperCAmelCase					,	UpperCAmelCase					,	UpperCAmelCase					,	unittest.TestCase      ):






			"""simple docstring"""






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




			@classmethod
			def 				snake_case__				(							cls     ):

						'''simple docstring'''


						super().setUpClass()
						torch.use_deterministic_algorithms(snake_case     )




			@classmethod
			def 				snake_case__				(							cls     ):

						'''simple docstring'''


						super().tearDownClass()
						torch.use_deterministic_algorithms(snake_case     )




			def 				snake_case__				(							self     ):

						'''simple docstring'''


						torch.manual_seed(0     )
						UpperCamelCase__					=       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=snake_case      ,						)
						UpperCamelCase__					=       DDIMScheduler(
						    beta_start=0.00085      ,						beta_end=0.012      ,						beta_schedule="scaled_linear"      ,						clip_sample=snake_case      ,						set_alpha_to_one=snake_case      ,						)
						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      ,						sample_size=128      ,						)
						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      ,						hidden_act="gelu"      ,						projection_dim=512      ,						)
						UpperCamelCase__					=       CLIPTextModel(snake_case     )
						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 				snake_case__				(							self      ,						snake_case      ,						snake_case=0     ):

						'''simple docstring'''


						if str(snake_case     ).startswith("mps"     ):
									UpperCamelCase__					=       torch.manual_seed(snake_case     )
						else:
									UpperCamelCase__					=       torch.Generator(device=snake_case     ).manual_seed(snake_case     )
						UpperCamelCase__					=       UpperCamelCase__					=       {
						    "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 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       "cpu"

						UpperCamelCase__					=       self.get_dummy_components()
						UpperCamelCase__					=       self.pipeline_class(**snake_case     )
						pipe.to(snake_case     )
						pipe.set_progress_bar_config(disable=snake_case     )

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

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




			def 				snake_case__				(							self     ):

						'''simple docstring'''


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




			def 				snake_case__				(							self     ):

						'''simple docstring'''


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




			def 				snake_case__				(							self     ):

						'''simple docstring'''


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




			def 				snake_case__				(							self     ):

						'''simple docstring'''


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




			def 				snake_case__				(							self     ):

						'''simple docstring'''


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




			def 				snake_case__				(							self     ):

						'''simple docstring'''


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







			def 				snake_case__				(							self     ):

						'''simple docstring'''


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







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






			"""simple docstring"""






			@classmethod
			def 				snake_case__				(							cls     ):

						'''simple docstring'''


						super().setUpClass()
						torch.use_deterministic_algorithms(snake_case     )




			@classmethod
			def 				snake_case__				(							cls     ):

						'''simple docstring'''


						super().tearDownClass()
						torch.use_deterministic_algorithms(snake_case     )




			def 				snake_case__				(							self     ):

						'''simple docstring'''


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







			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       torch.manual_seed(51     )

						UpperCamelCase__					=       StableDiffusionAttendAndExcitePipeline.from_pretrained(
						    "CompVis/stable-diffusion-v1-4"      ,						safety_checker=snake_case      ,						torch_dtype=torch.floataa     )
						pipe.to("cuda"     )

						UpperCamelCase__					=       "a painting of an elephant with glasses"
						UpperCamelCase__					=       [5, 7]

						UpperCamelCase__					=       pipe(
						    prompt=snake_case      ,						token_indices=snake_case      ,						guidance_scale=7.5      ,						generator=snake_case      ,						num_inference_steps=5      ,						max_iter_to_alter=5      ,						output_type="numpy"      ,						).images[0]

						UpperCamelCase__					=       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






from __future__ import annotations

import numpy as np
def        UpperCamelCase_(				_A   :list[float]  )->		Union[str, Any]:
			return np.maximum(0				,     _A  )


if __name__ == "__main__":
						print(np.array(relu([-1, 0, 5])))  # --> [0, 0, 5]


