
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


__magic_name__:					Optional[Any]							=     False





@skip_mps
class 	snake_case__ (							__lowerCAmelCase						,  __lowerCAmelCase						,  __lowerCAmelCase						,  unittest.TestCase				):
	lowercase__						:					Dict											=   StableDiffusionAttendAndExcitePipeline
	lowercase__						:					List[str]											=   False
	lowercase__						:					int											=   TEXT_TO_IMAGE_PARAMS
	lowercase__						:					Tuple											=   TEXT_TO_IMAGE_BATCH_PARAMS.union({'''token_indices'''}				)
	lowercase__						:					int											=   TEXT_TO_IMAGE_IMAGE_PARAMS
	lowercase__						:					Any											=   TEXT_TO_IMAGE_IMAGE_PARAMS
	@classmethod
	def       __magic_name__    (    cls			)							->				Union[str, Any]:
							super().setUpClass()
							torch.use_deterministic_algorithms(lowerCamelCase__			)
	@classmethod
	def       __magic_name__    (    cls			)							->				Dict:
							super().tearDownClass()
							torch.use_deterministic_algorithms(lowerCamelCase__			)
	def       __magic_name__    (    self			)							->				str:
							torch.manual_seed(0			)
							__magic_name__      :       Optional[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=lowerCamelCase__      ,       )
							__magic_name__      :       Union[str, Any]       						= DDIMScheduler(
							    beta_start=0.0_0_0_8_5      ,       beta_end=0.0_1_2      ,       beta_schedule="""scaled_linear"""      ,       clip_sample=lowerCamelCase__      ,       set_alpha_to_one=lowerCamelCase__      ,       )
							torch.manual_seed(0			)
							__magic_name__      :       List[Any]       						= 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=1_28      ,       )
							torch.manual_seed(0			)
							__magic_name__      :       Dict       						= CLIPTextConfig(
							    bos_token_id=0      ,       eos_token_id=2      ,       hidden_size=32      ,       intermediate_size=37      ,       layer_norm_eps=1e-0_5      ,       num_attention_heads=4      ,       num_hidden_layers=5      ,       pad_token_id=1      ,       vocab_size=10_00      ,       hidden_act="""gelu"""      ,       projection_dim=5_12      ,       )
							__magic_name__      :       str       						= CLIPTextModel(lowerCamelCase__			)
							__magic_name__      :       str       						= CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""			)

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

							return components
	def       __magic_name__    (    self      ,       lowerCAmelCase__      ,       lowerCAmelCase__=0			)							->				List[str]:






							if str(lowerCamelCase__			).startswith("""mps"""			):
													__magic_name__      :       List[str]       						= torch.manual_seed(lowerCamelCase__			)
							else:
													__magic_name__      :       List[Any]       						= torch.Generator(device=lowerCamelCase__			).manual_seed(lowerCamelCase__			)
							__magic_name__      :       Union[str, Any]       						= {
							    '''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       __magic_name__    (    self			)							->				Tuple:
							__magic_name__      :       Dict       						= '''cpu'''

							__magic_name__      :       List[Any]       						= self.get_dummy_components()
							__magic_name__      :       Optional[Any]       						= self.pipeline_class(**lowerCamelCase__			)
							pipe.to(lowerCamelCase__			)
							pipe.set_progress_bar_config(disable=lowerCamelCase__			)

							__magic_name__      :       Optional[int]       						= self.get_dummy_inputs(lowerCamelCase__			)
							__magic_name__      :       int       						= pipe(**lowerCamelCase__			).images
							__magic_name__      :       int       						= image[0, -3:, -3:, -1]

							self.assertEqual(image.shape      ,       (1, 64, 64, 3)			)
							__magic_name__      :       Optional[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]			)
							__magic_name__      :       List[str]       						= np.abs(image_slice.flatten() - expected_slice			).max()
							self.assertLessEqual(lowerCamelCase__      ,       1e-3			)
	def       __magic_name__    (    self			)							->				str:
							super().test_cpu_offload_forward_pass(expected_max_diff=5e-4			)
	def       __magic_name__    (    self			)							->				Optional[Any]:
							self._test_inference_batch_consistent(batch_sizes=[1, 2]			)
	def       __magic_name__    (    self			)							->				Union[str, Any]:
							self._test_inference_batch_single_identical(batch_size=2      ,       expected_max_diff=7e-4			)
	def       __magic_name__    (    self			)							->				Dict:
							super().test_dict_tuple_outputs_equivalent(expected_max_difference=3e-3			)
	def       __magic_name__    (    self			)							->				Optional[Any]:
							super().test_pt_np_pil_outputs_equivalent(expected_max_diff=5e-4			)
	def       __magic_name__    (    self			)							->				Union[str, Any]:
							super().test_save_load_local(expected_max_difference=5e-4			)







	def       __magic_name__    (    self			)							->				Tuple:
							super().test_save_load_optional_components(expected_max_difference=4e-4			)





@require_torch_gpu
@slow
class 	snake_case__ (							unittest.TestCase				):
	@classmethod
	def       __magic_name__    (    cls			)							->				Any:
							super().setUpClass()
							torch.use_deterministic_algorithms(lowerCamelCase__			)
	@classmethod
	def       __magic_name__    (    cls			)							->				Dict:
							super().tearDownClass()
							torch.use_deterministic_algorithms(lowerCamelCase__			)
	def       __magic_name__    (    self			)							->				Optional[Any]:
							super().tearDown()
							gc.collect()
							torch.cuda.empty_cache()







	def       __magic_name__    (    self			)							->				str:
							__magic_name__      :       int       						= torch.manual_seed(51			)

							__magic_name__      :       str       						= StableDiffusionAttendAndExcitePipeline.from_pretrained(
							    """CompVis/stable-diffusion-v1-4"""      ,       safety_checker=lowerCamelCase__      ,       torch_dtype=torch.floataa			)
							pipe.to("""cuda"""			)

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

							__magic_name__      :       Dict       						= pipe(
							    prompt=lowerCamelCase__      ,       token_indices=lowerCamelCase__      ,       guidance_scale=7.5      ,       generator=lowerCamelCase__      ,       num_inference_steps=5      ,       max_iter_to_alter=5      ,       output_type="""numpy"""      ,       ).images[0]

							__magic_name__      :       List[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








from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available


__magic_name__:					Tuple							=     {
    "configuration_tapas": ["TAPAS_PRETRAINED_CONFIG_ARCHIVE_MAP", "TapasConfig"],
    "tokenization_tapas": ["TapasTokenizer"],
}

try:
		if not is_torch_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		__magic_name__:					Dict							=     [
		    "TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST",
		    "TapasForMaskedLM",
		    "TapasForQuestionAnswering",
		    "TapasForSequenceClassification",
		    "TapasModel",
		    "TapasPreTrainedModel",
		    "load_tf_weights_in_tapas",
		]
try:
		if not is_tf_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		__magic_name__:					int							=     [
		    "TF_TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST",
		    "TFTapasForMaskedLM",
		    "TFTapasForQuestionAnswering",
		    "TFTapasForSequenceClassification",
		    "TFTapasModel",
		    "TFTapasPreTrainedModel",
		]


if TYPE_CHECKING:
		from .configuration_tapas import TAPAS_PRETRAINED_CONFIG_ARCHIVE_MAP, TapasConfig
		from .tokenization_tapas import TapasTokenizer

		try:
				if not is_torch_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_tapas import (
				    TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST,
				    TapasForMaskedLM,
				    TapasForQuestionAnswering,
				    TapasForSequenceClassification,
				    TapasModel,
				    TapasPreTrainedModel,
				    load_tf_weights_in_tapas,
				)

		try:
				if not is_tf_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_tf_tapas import (
				    TF_TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST,
				    TFTapasForMaskedLM,
				    TFTapasForQuestionAnswering,
				    TFTapasForSequenceClassification,
				    TFTapasModel,
				    TFTapasPreTrainedModel,
				)


else:
		import sys

		__magic_name__:					Tuple							=     _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
