





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


_SCREAMING_SNAKE_CASE      	=		False
@skip_mps
class SCREAMING_SNAKE_CASE_						(					snake_case_       ,				snake_case_       ,				snake_case_       ,				unittest.TestCase					):
						__magic_name__:			Optional[int]       =       StableDiffusionAttendAndExcitePipeline
						__magic_name__:			str       =       False
						__magic_name__:			List[Any]       =       TEXT_TO_IMAGE_PARAMS
						__magic_name__:			List[str]       =       TEXT_TO_IMAGE_BATCH_PARAMS.union({"token_indices"}					)
						__magic_name__:			Optional[int]       =       TEXT_TO_IMAGE_IMAGE_PARAMS
						__magic_name__:			Any       =       TEXT_TO_IMAGE_IMAGE_PARAMS






						@classmethod
						def UpperCAmelCase_				(      cls      :      List[Any]	)							->    Dict:







							"""simple docstring"""


							super().setUpClass()
							torch.use_deterministic_algorithms(_A	)






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







							"""simple docstring"""


							super().tearDownClass()
							torch.use_deterministic_algorithms(_A	)






						def UpperCAmelCase_				(      self      :      Optional[Any]	)							->    Any:







							"""simple docstring"""


							torch.manual_seed(0	)
							snake_case_		:			List[str]											=	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=_A		,   )
							snake_case_		:			Optional[Any]											=	DDIMScheduler(
							    beta_start=0.0_0_0_8_5		,   beta_end=0.0_1_2		,   beta_schedule='scaled_linear'		,   clip_sample=_A		,   set_alpha_to_one=_A		,   )
							torch.manual_seed(0	)
							snake_case_		:			List[str]											=	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	)
							snake_case_		:			Tuple											=	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		,   )
							snake_case_		:			List[Any]											=	CLIPTextModel(_A	)
							snake_case_		:			Any											=	CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'	)

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

							return components






						def UpperCAmelCase_				(      self      :      Tuple		,   _A      :      Optional[Any]		,   _A      :      Union[str, Any]=0	)							->    List[str]:







							"""simple docstring"""


							if str(_A	).startswith('mps'	):
								snake_case_		:			List[Any]											=	torch.manual_seed(_A	)
							else:
								snake_case_		:			str											=	torch.Generator(device=_A	).manual_seed(_A	)
							snake_case_		:			List[str]											=	{
							    '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 UpperCAmelCase_				(      self      :      List[Any]	)							->    Tuple:







							"""simple docstring"""


							snake_case_		:			Dict											=	'cpu'

							snake_case_		:			Any											=	self.get_dummy_components()
							snake_case_		:			Union[str, Any]											=	self.pipeline_class(**_A	)
							pipe.to(_A	)
							pipe.set_progress_bar_config(disable=_A	)

							snake_case_		:			Dict											=	self.get_dummy_inputs(_A	)
							snake_case_		:			Dict											=	pipe(**_A	).images
							snake_case_		:			Dict											=	image[0, -3:, -3:, -1]

							self.assertEqual(image.shape		,   (1, 64, 64, 3)	)
							snake_case_		:			Any											=	np.array(
							    [0.6_3_9_0_5_3_6_4, 0.6_2_8_9_7_3_0_7, 0.4_8_5_9_9_0_1_7, 0.5_1_3_3_6_2_4, 0.5_5_5_0_0_4_8, 0.4_5_7_6_9_5_1_6, 0.5_0_3_2_6_9_7_3, 0.5_0_2_3_1_3_9, 0.4_5_3_8_4_4_9_6]	)
							snake_case_		:			List[Any]											=	np.abs(image_slice.flatten() - expected_slice	).max()
							self.assertLessEqual(_A		,   1E-3	)






						def UpperCAmelCase_				(      self      :      int	)							->    List[str]:







							"""simple docstring"""


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






						def UpperCAmelCase_				(      self      :      List[Any]	)							->    Optional[Any]:







							"""simple docstring"""


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






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







							"""simple docstring"""


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






						def UpperCAmelCase_				(      self      :      Optional[Any]	)							->    str:







							"""simple docstring"""


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






						def UpperCAmelCase_				(      self      :      Tuple	)							->    int:







							"""simple docstring"""


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






						def UpperCAmelCase_				(      self      :      Any	)							->    List[str]:







							"""simple docstring"""


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






						def UpperCAmelCase_				(      self      :      int	)							->    Optional[Any]:







							"""simple docstring"""


							super().test_save_load_optional_components(expected_max_difference=4E-4	)
@require_torch_gpu
@slow
class SCREAMING_SNAKE_CASE_						(					unittest.TestCase					):






						@classmethod
						def UpperCAmelCase_				(      cls      :      Optional[Any]	)							->    Any:







							"""simple docstring"""


							super().setUpClass()
							torch.use_deterministic_algorithms(_A	)






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







							"""simple docstring"""


							super().tearDownClass()
							torch.use_deterministic_algorithms(_A	)






						def UpperCAmelCase_				(      self      :      Optional[int]	)							->    List[str]:







							"""simple docstring"""


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






						def UpperCAmelCase_				(      self      :      str	)							->    int:







							"""simple docstring"""


							snake_case_		:			Any											=	torch.manual_seed(51	)

							snake_case_		:			int											=	StableDiffusionAttendAndExcitePipeline.from_pretrained(
							    'CompVis/stable-diffusion-v1-4'		,   safety_checker=_A		,   torch_dtype=torch.floataa	)
							pipe.to('cuda'	)

							snake_case_		:			List[str]											=	'a painting of an elephant with glasses'
							snake_case_		:			Optional[int]											=	[5, 7]

							snake_case_		:			Optional[int]											=	pipe(
							    prompt=_A		,   token_indices=_A		,   guidance_scale=7.5		,   generator=_A		,   num_inference_steps=5		,   max_iter_to_alter=5		,   output_type='numpy'		,   ).images[0]

							snake_case_		:			Tuple											=	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 typing import TYPE_CHECKING

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


_SCREAMING_SNAKE_CASE      	=		{
    """configuration_lxmert""": ["""LXMERT_PRETRAINED_CONFIG_ARCHIVE_MAP""", """LxmertConfig"""],
    """tokenization_lxmert""": ["""LxmertTokenizer"""],
}

try:
						if not is_tokenizers_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						_SCREAMING_SNAKE_CASE      	=		["""LxmertTokenizerFast"""]

try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						_SCREAMING_SNAKE_CASE      	=		[
						    """LxmertEncoder""",
						    """LxmertForPreTraining""",
						    """LxmertForQuestionAnswering""",
						    """LxmertModel""",
						    """LxmertPreTrainedModel""",
						    """LxmertVisualFeatureEncoder""",
						    """LxmertXLayer""",
						]

try:
						if not is_tf_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						_SCREAMING_SNAKE_CASE      	=		[
						    """TF_LXMERT_PRETRAINED_MODEL_ARCHIVE_LIST""",
						    """TFLxmertForPreTraining""",
						    """TFLxmertMainLayer""",
						    """TFLxmertModel""",
						    """TFLxmertPreTrainedModel""",
						    """TFLxmertVisualFeatureEncoder""",
						]


if TYPE_CHECKING:
						from .configuration_lxmert import LXMERT_PRETRAINED_CONFIG_ARCHIVE_MAP, LxmertConfig
						from .tokenization_lxmert import LxmertTokenizer

						try:
												if not is_tokenizers_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .tokenization_lxmert_fast import LxmertTokenizerFast

						try:
												if not is_torch_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_lxmert import (
												    LxmertEncoder,
												    LxmertForPreTraining,
												    LxmertForQuestionAnswering,
												    LxmertModel,
												    LxmertPreTrainedModel,
												    LxmertVisualFeatureEncoder,
												    LxmertXLayer,
												)

						try:
												if not is_tf_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_tf_lxmert import (
												    TF_LXMERT_PRETRAINED_MODEL_ARCHIVE_LIST,
												    TFLxmertForPreTraining,
												    TFLxmertMainLayer,
												    TFLxmertModel,
												    TFLxmertPreTrainedModel,
												    TFLxmertVisualFeatureEncoder,
												)

else:
						import sys

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

