
"""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__		:int			  =   False







@skip_mps
class     lowercase		( SCREAMING_SNAKE_CASE__	,  SCREAMING_SNAKE_CASE__	,  SCREAMING_SNAKE_CASE__	,  unittest.TestCase		):
							lowercase_	:	Any	 =StableDiffusionAttendAndExcitePipeline
							lowercase_	:	int	 =False
							lowercase_	:	Tuple	 =TEXT_TO_IMAGE_PARAMS
							lowercase_	:	Optional[Any]	 =TEXT_TO_IMAGE_BATCH_PARAMS.union({'''token_indices'''}		)
							lowercase_	:	str	 =TEXT_TO_IMAGE_IMAGE_PARAMS
							lowercase_	:	Any	 =TEXT_TO_IMAGE_IMAGE_PARAMS




							@classmethod
							def 			A__				(    cls):
												super().setUpClass()
												torch.use_deterministic_algorithms(_snake_case)




							@classmethod
							def 			A__				(    cls):
												super().tearDownClass()
												torch.use_deterministic_algorithms(_snake_case)




							def 			A__				(    self):
												torch.manual_seed(0)
												lowercase						     =						UNetaDConditionModel(
												    block_out_channels=(3_2, 6_4)       ,layers_per_block=1       ,sample_size=3_2       ,in_channels=4       ,out_channels=4       ,down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')       ,up_block_types=('''CrossAttnUpBlock2D''', '''UpBlock2D''')       ,cross_attention_dim=3_2       ,attention_head_dim=(2, 4)       ,use_linear_projection=_snake_case       ,)
												lowercase						     =						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)
												lowercase						     =						AutoencoderKL(
												    block_out_channels=[3_2, 6_4]       ,in_channels=3       ,out_channels=3       ,down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D''']       ,up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D''']       ,latent_channels=4       ,sample_size=1_2_8       ,)
												torch.manual_seed(0)
												lowercase						     =						CLIPTextConfig(
												    bos_token_id=0       ,eos_token_id=2       ,hidden_size=3_2       ,intermediate_size=3_7       ,layer_norm_eps=1E-05       ,num_attention_heads=4       ,num_hidden_layers=5       ,pad_token_id=1       ,vocab_size=1_0_0_0       ,hidden_act='''gelu'''       ,projection_dim=5_1_2       ,)
												lowercase						     =						CLIPTextModel(_snake_case)
												lowercase						     =						CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip''')

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

												return components




							def 			A__				(    self       ,A__       ,A__=0):


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

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

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

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




							def 			A__				(    self):
												super().test_cpu_offload_forward_pass(expected_max_diff=5E-4)




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




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




							def 			A__				(    self):
												super().test_dict_tuple_outputs_equivalent(expected_max_difference=3E-3)




							def 			A__				(    self):
												super().test_pt_np_pil_outputs_equivalent(expected_max_diff=5E-4)




							def 			A__				(    self):
												super().test_save_load_local(expected_max_difference=5E-4)





							def 			A__				(    self):
												super().test_save_load_optional_components(expected_max_difference=4E-4)







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




							@classmethod
							def 			A__				(    cls):
												super().setUpClass()
												torch.use_deterministic_algorithms(_snake_case)




							@classmethod
							def 			A__				(    cls):
												super().tearDownClass()
												torch.use_deterministic_algorithms(_snake_case)




							def 			A__				(    self):
												super().tearDown()
												gc.collect()
												torch.cuda.empty_cache()





							def 			A__				(    self):
												lowercase						     =						torch.manual_seed(5_1)

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

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

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

												lowercase						     =						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_flax_available,
    is_tf_available,
    is_torch_available,
    is_vision_available,
)


lowercase__		:str			  =   {"configuration_vit": ["VIT_PRETRAINED_CONFIG_ARCHIVE_MAP", "ViTConfig", "ViTOnnxConfig"]}

try:
							if not is_vision_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							lowercase__		:str			  =   ["ViTFeatureExtractor"]
							lowercase__		:int			  =   ["ViTImageProcessor"]

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							lowercase__		:int			  =   [
							    "VIT_PRETRAINED_MODEL_ARCHIVE_LIST",
							    "ViTForImageClassification",
							    "ViTForMaskedImageModeling",
							    "ViTModel",
							    "ViTPreTrainedModel",
							]

try:
							if not is_tf_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							lowercase__		:Any			  =   [
							    "TFViTForImageClassification",
							    "TFViTModel",
							    "TFViTPreTrainedModel",
							]

try:
							if not is_flax_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							lowercase__		:Optional[int]			  =   [
							    "FlaxViTForImageClassification",
							    "FlaxViTModel",
							    "FlaxViTPreTrainedModel",
							]

if TYPE_CHECKING:
							from .configuration_vit import VIT_PRETRAINED_CONFIG_ARCHIVE_MAP, ViTConfig, ViTOnnxConfig

							try:
														if not is_vision_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .feature_extraction_vit import ViTFeatureExtractor
														from .image_processing_vit import ViTImageProcessor

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_vit import (
														    VIT_PRETRAINED_MODEL_ARCHIVE_LIST,
														    ViTForImageClassification,
														    ViTForMaskedImageModeling,
														    ViTModel,
														    ViTPreTrainedModel,
														)

							try:
														if not is_tf_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_tf_vit import TFViTForImageClassification, TFViTModel, TFViTPreTrainedModel

							try:
														if not is_flax_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_flax_vit import FlaxViTForImageClassification, FlaxViTModel, FlaxViTPreTrainedModel


else:
							import sys

							lowercase__		:Dict			  =   _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)




