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







@skip_mps
class 			__A( a  ,   a  ,   a  ,   unittest.TestCase			):
				snake_case_						   =    StableDiffusionAttendAndExcitePipeline
				snake_case_						   =    False
				snake_case_						   =    TEXT_TO_IMAGE_PARAMS
				snake_case_						   =    TEXT_TO_IMAGE_BATCH_PARAMS.union({'''token_indices'''}			)
				snake_case_						   =    TEXT_TO_IMAGE_IMAGE_PARAMS
				snake_case_						   =    TEXT_TO_IMAGE_IMAGE_PARAMS




				@classmethod
				def 				SCREAMING_SNAKE_CASE_		(     cls				)    ->      List[str]:


								'''simple docstring'''




								super().setUpClass()
								torch.use_deterministic_algorithms(_snake_case				)




				@classmethod
				def 				SCREAMING_SNAKE_CASE_		(     cls				)    ->      int:


								'''simple docstring'''




								super().tearDownClass()
								torch.use_deterministic_algorithms(_snake_case				)




				def 				SCREAMING_SNAKE_CASE_		(     self				)    ->      Union[str, Any]:


								'''simple docstring'''




								torch.manual_seed(0				)
								__a										=    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		,     )
								__a										=    DDIMScheduler(
								    beta_start=0.0_0085		,     beta_end=0.012		,     beta_schedule='''scaled_linear'''		,     clip_sample=_snake_case		,     set_alpha_to_one=_snake_case		,     )
								torch.manual_seed(0				)
								__a										=    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										=    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		,     hidden_act='''gelu'''		,     projection_dim=512		,     )
								__a										=    CLIPTextModel(_snake_case				)
								__a										=    CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''				)

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

								return components




				def 				SCREAMING_SNAKE_CASE_		(     self		,     _snake_case		,     _snake_case=0				)    ->      Any:


								'''simple docstring'''




								if str(_snake_case				).startswith('''mps'''				):
												__a										=    torch.manual_seed(_snake_case				)
								else:
												__a										=    torch.Generator(device=_snake_case				).manual_seed(_snake_case				)
								__a										=    __a										=    {
								    '''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 				SCREAMING_SNAKE_CASE_		(     self				)    ->      Tuple:


								'''simple docstring'''




								__a										=    '''cpu'''

								__a										=    self.get_dummy_components()
								__a										=    self.pipeline_class(**_snake_case				)
								pipe.to(_snake_case				)
								pipe.set_progress_bar_config(disable=_snake_case				)

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

								self.assertEqual(image.shape		,     (1, 64, 64, 3)				)
								__a										=    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										=    np.abs(image_slice.flatten() - expected_slice				).max()
								self.assertLessEqual(_snake_case		,     1E-3				)




				def 				SCREAMING_SNAKE_CASE_		(     self				)    ->      Optional[int]:


								'''simple docstring'''




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




				def 				SCREAMING_SNAKE_CASE_		(     self				)    ->      Union[str, Any]:


								'''simple docstring'''




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




				def 				SCREAMING_SNAKE_CASE_		(     self				)    ->      str:


								'''simple docstring'''




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




				def 				SCREAMING_SNAKE_CASE_		(     self				)    ->      Optional[int]:


								'''simple docstring'''




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




				def 				SCREAMING_SNAKE_CASE_		(     self				)    ->      str:


								'''simple docstring'''




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




				def 				SCREAMING_SNAKE_CASE_		(     self				)    ->      Dict:


								'''simple docstring'''




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




				def 				SCREAMING_SNAKE_CASE_		(     self				)    ->      Union[str, Any]:


								'''simple docstring'''




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







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




				@classmethod
				def 				SCREAMING_SNAKE_CASE_		(     cls				)    ->      Dict:


								'''simple docstring'''




								super().setUpClass()
								torch.use_deterministic_algorithms(_snake_case				)




				@classmethod
				def 				SCREAMING_SNAKE_CASE_		(     cls				)    ->      Union[str, Any]:


								'''simple docstring'''




								super().tearDownClass()
								torch.use_deterministic_algorithms(_snake_case				)




				def 				SCREAMING_SNAKE_CASE_		(     self				)    ->      List[str]:


								'''simple docstring'''




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




				def 				SCREAMING_SNAKE_CASE_		(     self				)    ->      List[Any]:


								'''simple docstring'''




								__a										=    torch.manual_seed(51				)

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

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

								__a										=    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]

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

# NOTE: This file is deprecated and will be removed in a future version.
# It only exists so that temporarely `from diffusers.pipelines import DiffusionPipeline` works
from ...utils import deprecate
from ..controlnet.multicontrolnet import MultiControlNetModel  # noqa: F401
from ..controlnet.pipeline_controlnet import StableDiffusionControlNetPipeline  # noqa: F401


deprecate(
    'stable diffusion controlnet',
    '0.22.0',
    'Importing `StableDiffusionControlNetPipeline` or `MultiControlNetModel` from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_controlnet is deprecated. Please import `from diffusers import StableDiffusionControlNetPipeline` instead.',
    standard_warn=False,
    stacklevel=3,
)