


'''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 					lowercase						(  a_,					a_,					a_,					unittest.TestCase ):
							_lowerCamelCase		:      Optional[int]=   StableDiffusionAttendAndExcitePipeline
							_lowerCamelCase		:      Dict=   False
							_lowerCamelCase		:      Dict=   TEXT_TO_IMAGE_PARAMS
							_lowerCamelCase		:      Optional[int]=   TEXT_TO_IMAGE_BATCH_PARAMS.union({"token_indices"} )
							_lowerCamelCase		:      Dict=   TEXT_TO_IMAGE_IMAGE_PARAMS
							_lowerCamelCase		:      Tuple=   TEXT_TO_IMAGE_IMAGE_PARAMS


							@classmethod
							def 						_snake_case							(			cls)							->				List[Any]:
								super().setUpClass()
								torch.use_deterministic_algorithms(_snake_case)


							@classmethod
							def 						_snake_case							(			cls)							->				str:
								super().tearDownClass()
								torch.use_deterministic_algorithms(_snake_case)


							def 						_snake_case							(			self)							->				Optional[int]:
								torch.manual_seed(0)
								UpperCAmelCase_		:      int       	=					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_		:      Any       	=					DDIMScheduler(
								    beta_start=0.00_085    ,			beta_end=0.012    ,			beta_schedule='scaled_linear'    ,			clip_sample=_snake_case    ,			set_alpha_to_one=_snake_case    ,			)
								torch.manual_seed(0)
								UpperCAmelCase_		:      Dict       	=					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_		:      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    ,			)
								UpperCAmelCase_		:      Union[str, Any]       	=					CLIPTextModel(_snake_case)
								UpperCAmelCase_		:      Any       	=					CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip')

								UpperCAmelCase_		:      Tuple       	=					{
								    '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)							->				int:
								if str(_snake_case).startswith('mps'):
									UpperCAmelCase_		:      int       	=					torch.manual_seed(_snake_case)
								else:
									UpperCAmelCase_		:      List[str]       	=					torch.Generator(device=_snake_case).manual_seed(_snake_case)
								UpperCAmelCase_		:      Optional[int]       	=					{
								    '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)							->				Optional[int]:
								UpperCAmelCase_		:      Dict       	=					'cpu'

								UpperCAmelCase_		:      str       	=					self.get_dummy_components()
								UpperCAmelCase_		:      Dict       	=					self.pipeline_class(**_snake_case)
								pipe.to(_snake_case)
								pipe.set_progress_bar_config(disable=_snake_case)

								UpperCAmelCase_		:      Any       	=					self.get_dummy_inputs(_snake_case)
								UpperCAmelCase_		:      str       	=					pipe(**_snake_case).images
								UpperCAmelCase_		:      int       	=					image[0, -3:, -3:, -1]

								self.assertEqual(image.shape    ,			(1, 64, 64, 3))
								UpperCAmelCase_		:      List[Any]       	=					np.array(
								    [0.63_905_364, 0.62_897_307, 0.48_599_017, 0.5_133_624, 0.5_550_048, 0.45_769_516, 0.50_326_973, 0.5_023_139, 0.45_384_496])
								UpperCAmelCase_		:      Any       	=					np.abs(image_slice.flatten() - expected_slice).max()
								self.assertLessEqual(_snake_case    ,			1e-3)


							def 						_snake_case							(			self)							->				Any:
								super().test_cpu_offload_forward_pass(expected_max_diff=5e-4)


							def 						_snake_case							(			self)							->				Optional[int]:
								# NOTE: Larger batch sizes cause this test to timeout, only test on smaller batches
								self._test_inference_batch_consistent(batch_sizes=[1, 2])


							def 						_snake_case							(			self)							->				int:
								self._test_inference_batch_single_identical(batch_size=2    ,			expected_max_diff=7e-4)


							def 						_snake_case							(			self)							->				Optional[Any]:
								super().test_dict_tuple_outputs_equivalent(expected_max_difference=3e-3)


							def 						_snake_case							(			self)							->				Any:
								super().test_pt_np_pil_outputs_equivalent(expected_max_diff=5e-4)


							def 						_snake_case							(			self)							->				List[Any]:
								super().test_save_load_local(expected_max_difference=5e-4)





							def 						_snake_case							(			self)							->				Any:
								super().test_save_load_optional_components(expected_max_difference=4e-4)



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


							@classmethod
							def 						_snake_case							(			cls)							->				Optional[Any]:
								super().setUpClass()
								torch.use_deterministic_algorithms(_snake_case)


							@classmethod
							def 						_snake_case							(			cls)							->				List[Any]:
								super().tearDownClass()
								torch.use_deterministic_algorithms(_snake_case)


							def 						_snake_case							(			self)							->				int:
								super().tearDown()
								gc.collect()
								torch.cuda.empty_cache()





							def 						_snake_case							(			self)							->				str:
								UpperCAmelCase_		:      Optional[int]       	=					torch.manual_seed(51)

								UpperCAmelCase_		:      Optional[Any]       	=					StableDiffusionAttendAndExcitePipeline.from_pretrained(
								    'CompVis/stable-diffusion-v1-4'    ,			safety_checker=_snake_case    ,			torch_dtype=torch.floataa)
								pipe.to('cuda')

								UpperCAmelCase_		:      Dict       	=					'a painting of an elephant with glasses'
								UpperCAmelCase_		:      Union[str, Any]       	=					[5, 7]

								UpperCAmelCase_		:      str       	=					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_		:      Optional[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 typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


lowerCAmelCase__										= {
    "configuration_clap": [
        "CLAP_PRETRAINED_MODEL_ARCHIVE_LIST",
        "ClapAudioConfig",
        "ClapConfig",
        "ClapTextConfig",
    ],
    "processing_clap": ["ClapProcessor"],
}

try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						lowerCAmelCase__										= [
						    "CLAP_PRETRAINED_MODEL_ARCHIVE_LIST",
						    "ClapModel",
						    "ClapPreTrainedModel",
						    "ClapTextModel",
						    "ClapTextModelWithProjection",
						    "ClapAudioModel",
						    "ClapAudioModelWithProjection",
						]
						lowerCAmelCase__										= ["ClapFeatureExtractor"]

if TYPE_CHECKING:
						from .configuration_clap import (
						    CLAP_PRETRAINED_MODEL_ARCHIVE_LIST,
						    ClapAudioConfig,
						    ClapConfig,
						    ClapTextConfig,
						)
						from .processing_clap import ClapProcessor

						try:
												if not is_torch_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .feature_extraction_clap import ClapFeatureExtractor
												from .modeling_clap import (
												    CLAP_PRETRAINED_MODEL_ARCHIVE_LIST,
												    ClapAudioModel,
												    ClapAudioModelWithProjection,
												    ClapModel,
												    ClapPreTrainedModel,
												    ClapTextModel,
												    ClapTextModelWithProjection,
												)


else:
						import sys

						lowerCAmelCase__										= _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)






