




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       :	List[str]									=     False







@skip_mps
class 						A(		lowercase__							,   lowercase__							,   lowercase__							,   unittest.TestCase     ):



 '''simple docstring'''


 UpperCamelCase		     =		StableDiffusionAttendAndExcitePipeline
 UpperCamelCase		     =		False
 UpperCamelCase		     =		TEXT_TO_IMAGE_PARAMS
 UpperCamelCase		     =		TEXT_TO_IMAGE_BATCH_PARAMS.union({'''token_indices'''}     )
 UpperCamelCase		     =		TEXT_TO_IMAGE_IMAGE_PARAMS
 UpperCamelCase		     =		TEXT_TO_IMAGE_IMAGE_PARAMS

 @classmethod
 def        a__				(       cls      :						Any						)     ->			Any:

       """simple docstring"""






       super().setUpClass()
       torch.use_deterministic_algorithms(UpperCAmelCase__						)

 @classmethod
 def        a__				(       cls      :						Optional[int]						)     ->			int:

       """simple docstring"""






       super().tearDownClass()
       torch.use_deterministic_algorithms(UpperCAmelCase__						)

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

       """simple docstring"""






       torch.manual_seed(0						)
       lowerCamelCase_	  =					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__		,							)
       lowerCamelCase_	  =					DDIMScheduler(
           beta_start=0.00085		,							beta_end=0.012		,							beta_schedule='scaled_linear'		,							clip_sample=UpperCAmelCase__		,							set_alpha_to_one=UpperCAmelCase__		,							)
       torch.manual_seed(0						)
       lowerCamelCase_	  =					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						)
       lowerCamelCase_	  =					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		,							)
       lowerCamelCase_	  =					CLIPTextModel(UpperCAmelCase__						)
       lowerCamelCase_	  =					CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'						)

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

       return components

 def        a__				(       self      :						int		,							A_      :						List[Any]		,							A_      :						Optional[int]=0						)     ->			List[Any]:

       """simple docstring"""






       if str(UpperCAmelCase__						).startswith('mps'						):
             lowerCamelCase_	  =					torch.manual_seed(UpperCAmelCase__						)
       else:
             lowerCamelCase_	  =					torch.Generator(device=UpperCAmelCase__						).manual_seed(UpperCAmelCase__						)
       lowerCamelCase_	  =					{
           '''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      :						Optional[Any]						)     ->			int:

       """simple docstring"""






       lowerCamelCase_	  =					'''cpu'''

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

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

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

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

       """simple docstring"""






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

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

       """simple docstring"""






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

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

       """simple docstring"""






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

 def        a__				(       self      :						Optional[int]						)     ->			int:

       """simple docstring"""






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

 def        a__				(       self      :						str						)     ->			str:

       """simple docstring"""






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

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

       """simple docstring"""






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





 def        a__				(       self      :						List[str]						)     ->			str:

       """simple docstring"""






       super().test_save_load_optional_components(expected_max_difference=4E-4						)







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



 '''simple docstring'''


 @classmethod
 def        a__				(       cls      :						Tuple						)     ->			Union[str, Any]:

       """simple docstring"""






       super().setUpClass()
       torch.use_deterministic_algorithms(UpperCAmelCase__						)

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

       """simple docstring"""






       super().tearDownClass()
       torch.use_deterministic_algorithms(UpperCAmelCase__						)

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

       """simple docstring"""






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





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

       """simple docstring"""






       lowerCamelCase_	  =					torch.manual_seed(51						)

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

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

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

       lowerCamelCase_	  =					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 Dict, Iterable, List, Optional, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import (
    center_crop,
    get_resize_output_image_size,
    normalize,
    rescale,
    resize,
    to_channel_dimension_format,
)
from ...image_utils import (
    IMAGENET_DEFAULT_MEAN,
    IMAGENET_DEFAULT_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, logging


lowerCamelCase       :	List[Any]									=     logging.get_logger(__name__)







class 						A(		UpperCamelCase     ):



 '''simple docstring'''


 UpperCamelCase		     =		['''pixel_values''']

 def __init__(       self      :						List[Any]		,							A_      :						bool = True		,							A_      :						Dict[str, int] = None		,							A_      :						PILImageResampling = PILImageResampling.BICUBIC		,							A_      :						bool = True		,							A_      :						Dict[str, int] = None		,							A_      :						bool = True		,							A_      :						Union[int, float] = 1 / 255		,							A_      :						bool = True		,							A_      :						Optional[Union[float, Iterable[float]]] = IMAGENET_DEFAULT_MEAN		,							A_      :						Optional[Union[float, Iterable[float]]] = IMAGENET_DEFAULT_STD		,							**A_      :						Tuple		,							)     ->			None:

       """simple docstring"""






       super().__init__(**A_						)
       lowerCamelCase_	  =					size if size is not None else {'shortest_edge': 224}
       lowerCamelCase_	  =					get_size_dict(A_		,							default_to_square=A_						)
       lowerCamelCase_	  =					crop_size if crop_size is not None else {'height': 224, 'width': 224}
       lowerCamelCase_	  =					get_size_dict(A_		,							param_name='crop_size'						)

       lowerCamelCase_	  =					do_resize
       lowerCamelCase_	  =					size
       lowerCamelCase_	  =					resample
       lowerCamelCase_	  =					do_center_crop
       lowerCamelCase_	  =					crop_size
       lowerCamelCase_	  =					do_rescale
       lowerCamelCase_	  =					rescale_factor
       lowerCamelCase_	  =					do_normalize
       lowerCamelCase_	  =					image_mean if image_mean is not None else IMAGENET_DEFAULT_MEAN
       lowerCamelCase_	  =					image_std if image_std is not None else IMAGENET_DEFAULT_STD

 def        a__				(       self      :						Optional[Any]		,							A_      :						np.ndarray		,							A_      :						Dict[str, int]		,							A_      :						PILImageResampling = PILImageResampling.BICUBIC		,							A_      :						Optional[Union[str, ChannelDimension]] = None		,							**A_      :						Tuple		,							)     ->			np.ndarray:

       """simple docstring"""






       lowerCamelCase_	  =					get_size_dict(A_		,							default_to_square=A_						)
       # size_dict is a dict with either keys "height" and "width" or "shortest_edge"
       if "shortest_edge" in size:
             lowerCamelCase_	  =					int((256 / 224) * size['shortest_edge']						)
             lowerCamelCase_	  =					get_resize_output_image_size(A_		,							size=A_		,							default_to_square=A_						)
             lowerCamelCase_	  =					{'height': output_size[0], 'width': output_size[1]}
       if "height" not in size_dict or "width" not in size_dict:
             raise ValueError(
                 f"""Size dict must have keys 'height' and 'width' or 'shortest_edge'. Got {size_dict.keys()}"""						)
       return resize(
           A_		,							size=(size_dict['height'], size_dict['width'])		,							resample=A_		,							data_format=A_		,							**A_						)

 def        a__				(       self      :						Any		,							A_      :						np.ndarray		,							A_      :						Dict[str, int]		,							A_      :						Optional[Union[str, ChannelDimension]] = None		,							**A_      :						Any		,							)     ->			np.ndarray:

       """simple docstring"""






       lowerCamelCase_	  =					get_size_dict(A_						)
       if "height" not in size or "width" not in size:
             raise ValueError(f"""Size dict must have keys 'height' and 'width'. Got {size.keys()}"""						)
       return center_crop(A_		,							size=(size['height'], size['width'])		,							data_format=A_		,							**A_						)

 def        a__				(       self      :						Optional[Any]		,							A_      :						np.ndarray		,							A_      :						Union[int, float]		,							A_      :						Optional[Union[str, ChannelDimension]] = None		,							**A_      :						Optional[int]		,							)     ->			np.ndarray:

       """simple docstring"""






       return rescale(A_		,							scale=A_		,							data_format=A_		,							**A_						)

 def        a__				(       self      :						List[str]		,							A_      :						np.ndarray		,							A_      :						Union[float, List[float]]		,							A_      :						Union[float, List[float]]		,							A_      :						Optional[Union[str, ChannelDimension]] = None		,							**A_      :						str		,							)     ->			np.ndarray:

       """simple docstring"""






       return normalize(A_		,							mean=A_		,							std=A_		,							data_format=A_		,							**A_						)





 def        a__				(       self      :						Optional[int]		,							A_      :						ImageInput		,							A_      :						Optional[bool] = None		,							A_      :						Optional[Dict[str, int]] = None		,							A_      :						PILImageResampling = None		,							A_      :						Optional[bool] = None		,							A_      :						Optional[Dict[str, int]] = None		,							A_      :						Optional[bool] = None		,							A_      :						Optional[float] = None		,							A_      :						Optional[bool] = None		,							A_      :						Optional[Union[float, Iterable[float]]] = None		,							A_      :						Optional[Union[float, Iterable[float]]] = None		,							A_      :						Optional[TensorType] = None		,							A_      :						ChannelDimension = ChannelDimension.FIRST		,							**A_      :						List[Any]		,							)     ->			BatchFeature:

       """simple docstring"""






       lowerCamelCase_	  =					do_resize if do_resize is not None else self.do_resize
       lowerCamelCase_	  =					resample if resample is not None else self.resample
       lowerCamelCase_	  =					do_center_crop if do_center_crop is not None else self.do_center_crop
       lowerCamelCase_	  =					do_rescale if do_rescale is not None else self.do_rescale
       lowerCamelCase_	  =					rescale_factor if rescale_factor is not None else self.rescale_factor
       lowerCamelCase_	  =					do_normalize if do_normalize is not None else self.do_normalize
       lowerCamelCase_	  =					image_mean if image_mean is not None else self.image_mean
       lowerCamelCase_	  =					image_std if image_std is not None else self.image_std

       lowerCamelCase_	  =					size if size is not None else self.size
       lowerCamelCase_	  =					get_size_dict(A_		,							default_to_square=A_						)
       lowerCamelCase_	  =					crop_size if crop_size is not None else self.crop_size
       lowerCamelCase_	  =					get_size_dict(A_		,							param_name='crop_size'						)

       lowerCamelCase_	  =					make_list_of_images(A_						)

       if not valid_images(A_						):
             raise ValueError(
                 'Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, '
                 'torch.Tensor, tf.Tensor or jax.ndarray.'						)

       if do_resize and size is None:
             raise ValueError('Size must be specified if do_resize is True.'						)

       if do_center_crop and crop_size is None:
             raise ValueError('Crop size must be specified if do_center_crop is True.'						)

       if do_rescale and rescale_factor is None:
             raise ValueError('Rescale factor must be specified if do_rescale is True.'						)

       if do_normalize and (image_mean is None or image_std is None):
             raise ValueError('Image mean and std must be specified if do_normalize is True.'						)

       # All transformations expect numpy arrays.
       lowerCamelCase_	  =					[to_numpy_array(A_						) for image in images]

       if do_resize:
             lowerCamelCase_	  =					[self.resize(A_		,							A_		,							A_						) for image in images]

       if do_center_crop:
             lowerCamelCase_	  =					[self.center_crop(A_		,							A_						) for image in images]

       if do_rescale:
             lowerCamelCase_	  =					[self.rescale(A_		,							A_						) for image in images]

       if do_normalize:
             lowerCamelCase_	  =					[self.normalize(A_		,							A_		,							A_						) for image in images]

       lowerCamelCase_	  =					[to_channel_dimension_format(A_		,							A_						) for image in images]

       lowerCamelCase_	  =					{'pixel_values': images}
       return BatchFeature(data=A_		,							tensor_type=A_						)



