
"""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 				__lowercase				(      lowercase__		,					lowercase__		,					lowercase__		,					unittest.TestCase    ):



						'''simple docstring'''


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


						@classmethod
						def 						_SCREAMING_SNAKE_CASE      ( cls     :      Any      )     ->   Dict:
							super().setUpClass()
							torch.use_deterministic_algorithms(UpperCAmelCase__      )


						@classmethod
						def 						_SCREAMING_SNAKE_CASE      ( cls     :      Optional[int]      )     ->   Optional[Any]:
							super().tearDownClass()
							torch.use_deterministic_algorithms(UpperCAmelCase__      )


						def 						_SCREAMING_SNAKE_CASE      ( self     :      List[str]      )     ->   Optional[int]:
							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=UpperCAmelCase__  ,)
							A						   =   DDIMScheduler(
							    beta_start=0.0_00_85  ,beta_end=0.0_12  ,beta_schedule='scaled_linear'  ,clip_sample=UpperCAmelCase__  ,set_alpha_to_one=UpperCAmelCase__  ,)
							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=1000  ,hidden_act='gelu'  ,projection_dim=512  ,)
							A						   =   CLIPTextModel(UpperCAmelCase__      )
							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     :      int  ,A_     :      List[Any]  ,A_     :      Optional[int]=0      )     ->   Dict:
							if str(UpperCAmelCase__      ).startswith('mps'      ):
								A						   =   torch.manual_seed(UpperCAmelCase__      )
							else:
								A						   =   torch.Generator(device=UpperCAmelCase__      ).manual_seed(UpperCAmelCase__      )
							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     :      Optional[Any]      )     ->   Optional[int]:
							A						   =   '''cpu'''

							A						   =   self.get_dummy_components()
							A						   =   self.pipeline_class(**UpperCAmelCase__      )
							pipe.to(UpperCAmelCase__      )
							pipe.set_progress_bar_config(disable=UpperCAmelCase__      )

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

							self.assertEqual(image.shape  ,(1, 64, 64, 3)      )
							A						   =   np.array(
							    [0.63_90_53_64, 0.62_89_73_07, 0.48_59_90_17, 0.5_13_36_24, 0.5_55_00_48, 0.45_76_95_16, 0.50_32_69_73, 0.5_02_31_39, 0.45_38_44_96]      )
							A						   =   np.abs(image_slice.flatten() - expected_slice      ).max()
							self.assertLessEqual(UpperCAmelCase__  ,1e-3      )


						def 						_SCREAMING_SNAKE_CASE      ( self     :      List[str]      )     ->   List[Any]:
							super().test_cpu_offload_forward_pass(expected_max_diff=5e-4      )


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


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


						def 						_SCREAMING_SNAKE_CASE      ( self     :      Optional[int]      )     ->   Union[str, Any]:
							super().test_dict_tuple_outputs_equivalent(expected_max_difference=3e-3      )


						def 						_SCREAMING_SNAKE_CASE      ( self     :      str      )     ->   Tuple:
							super().test_pt_np_pil_outputs_equivalent(expected_max_diff=5e-4      )


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




						def 						_SCREAMING_SNAKE_CASE      ( self     :      List[str]      )     ->   Any:
							super().test_save_load_optional_components(expected_max_difference=4e-4      )







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



						'''simple docstring'''


						@classmethod
						def 						_SCREAMING_SNAKE_CASE      ( cls     :      Tuple      )     ->   int:
							super().setUpClass()
							torch.use_deterministic_algorithms(UpperCAmelCase__      )


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


						def 						_SCREAMING_SNAKE_CASE      ( self     :      Optional[Any]      )     ->   Optional[Any]:
							super().tearDown()
							gc.collect()
							torch.cuda.empty_cache()




						def 						_SCREAMING_SNAKE_CASE      ( self     :      Union[str, Any]      )     ->   List[str]:
							A						   =   torch.manual_seed(51      )

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

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

							A						   =   pipe(
							    prompt=UpperCAmelCase__  ,token_indices=UpperCAmelCase__  ,guidance_scale=7.5  ,generator=UpperCAmelCase__  ,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

"""simple docstring"""


from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
    is_vision_available,
)


_lowercase							   =				{
    '''configuration_clip''': [
        '''CLIP_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''CLIPConfig''',
        '''CLIPOnnxConfig''',
        '''CLIPTextConfig''',
        '''CLIPVisionConfig''',
    ],
    '''processing_clip''': ['''CLIPProcessor'''],
    '''tokenization_clip''': ['''CLIPTokenizer'''],
}

try:
		if not is_tokenizers_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		_lowercase							   =				['''CLIPTokenizerFast''']

try:
		if not is_vision_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		_lowercase							   =				['''CLIPFeatureExtractor''']
		_lowercase							   =				['''CLIPImageProcessor''']

try:
		if not is_torch_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		_lowercase							   =				[
		    '''CLIP_PRETRAINED_MODEL_ARCHIVE_LIST''',
		    '''CLIPModel''',
		    '''CLIPPreTrainedModel''',
		    '''CLIPTextModel''',
		    '''CLIPTextModelWithProjection''',
		    '''CLIPVisionModel''',
		    '''CLIPVisionModelWithProjection''',
		]

try:
		if not is_tf_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		_lowercase							   =				[
		    '''TF_CLIP_PRETRAINED_MODEL_ARCHIVE_LIST''',
		    '''TFCLIPModel''',
		    '''TFCLIPPreTrainedModel''',
		    '''TFCLIPTextModel''',
		    '''TFCLIPVisionModel''',
		]

try:
		if not is_flax_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		_lowercase							   =				[
		    '''FlaxCLIPModel''',
		    '''FlaxCLIPPreTrainedModel''',
		    '''FlaxCLIPTextModel''',
		    '''FlaxCLIPTextPreTrainedModel''',
		    '''FlaxCLIPVisionModel''',
		    '''FlaxCLIPVisionPreTrainedModel''',
		]


if TYPE_CHECKING:
		from .configuration_clip import (
		    CLIP_PRETRAINED_CONFIG_ARCHIVE_MAP,
		    CLIPConfig,
		    CLIPOnnxConfig,
		    CLIPTextConfig,
		    CLIPVisionConfig,
		)
		from .processing_clip import CLIPProcessor
		from .tokenization_clip import CLIPTokenizer

		try:
				if not is_tokenizers_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .tokenization_clip_fast import CLIPTokenizerFast

		try:
				if not is_vision_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .feature_extraction_clip import CLIPFeatureExtractor
				from .image_processing_clip import CLIPImageProcessor

		try:
				if not is_torch_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_clip import (
				    CLIP_PRETRAINED_MODEL_ARCHIVE_LIST,
				    CLIPModel,
				    CLIPPreTrainedModel,
				    CLIPTextModel,
				    CLIPTextModelWithProjection,
				    CLIPVisionModel,
				    CLIPVisionModelWithProjection,
				)

		try:
				if not is_tf_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_tf_clip import (
				    TF_CLIP_PRETRAINED_MODEL_ARCHIVE_LIST,
				    TFCLIPModel,
				    TFCLIPPreTrainedModel,
				    TFCLIPTextModel,
				    TFCLIPVisionModel,
				)

		try:
				if not is_flax_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_flax_clip import (
				    FlaxCLIPModel,
				    FlaxCLIPPreTrainedModel,
				    FlaxCLIPTextModel,
				    FlaxCLIPTextPreTrainedModel,
				    FlaxCLIPVisionModel,
				    FlaxCLIPVisionPreTrainedModel,
				)


else:
		import sys

		_lowercase							   =				_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)