



'''simple docstring'''






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:      str		 =		logging.get_logger(__name__)

class 							a__(      lowerCamelCase__			):
    lowercase__				=					["""pixel_values"""]







    def __init__(   self				:						Optional[Any]		,    __snake_case				:						bool = True		,    __snake_case				:						Dict[str, int] = None		,    __snake_case				:						PILImageResampling = PILImageResampling.BICUBIC		,    __snake_case				:						bool = True		,    __snake_case				:						Dict[str, int] = None		,    __snake_case				:						bool = True		,    __snake_case				:						Union[int, float] = 1 / 2_55		,    __snake_case				:						bool = True		,    __snake_case				:						Optional[Union[float, Iterable[float]]] = IMAGENET_DEFAULT_MEAN		,    __snake_case				:						Optional[Union[float, Iterable[float]]] = IMAGENET_DEFAULT_STD		,    **__snake_case				:						Tuple		,    ):
      super().__init__(**__snake_case			)
      a		:      List[Any]       =  size if size is not None else {'shortest_edge': 2_24}
      a		:      List[Any]       =  get_size_dict(__snake_case		,    default_to_square=__snake_case			)
      a		:      List[str]       =  crop_size if crop_size is not None else {'height': 2_24, 'width': 2_24}
      a		:      Optional[Any]       =  get_size_dict(__snake_case		,    param_name='crop_size'			)

      a		:      Any       =  do_resize
      a		:      Optional[int]       =  size
      a		:      Any       =  resample
      a		:      Tuple       =  do_center_crop
      a		:      List[str]       =  crop_size
      a		:      List[Any]       =  do_rescale
      a		:      List[str]       =  rescale_factor
      a		:      Union[str, Any]       =  do_normalize
      a		:      List[Any]       =  image_mean if image_mean is not None else IMAGENET_DEFAULT_MEAN
      a		:      Optional[Any]       =  image_std if image_std is not None else IMAGENET_DEFAULT_STD







    def     lowercase_ (   self				:						Dict		,    __snake_case				:						np.ndarray		,    __snake_case				:						Dict[str, int]		,    __snake_case				:						PILImageResampling = PILImageResampling.BICUBIC		,    __snake_case				:						Optional[Union[str, ChannelDimension]] = None		,    **__snake_case				:						List[str]		,    ):
      a		:      Optional[Any]       =  get_size_dict(__snake_case		,    default_to_square=__snake_case			)
      # size_dict is a dict with either keys "height" and "width" or "shortest_edge"
      if "shortest_edge" in size:
        a		:      Tuple       =  int((2_56 / 2_24) * size['shortest_edge']			)
        a		:      Optional[Any]       =  get_resize_output_image_size(__snake_case		,    size=__snake_case		,    default_to_square=__snake_case			)
        a		:      Tuple       =  {'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(
          __snake_case		,    size=(size_dict['height'], size_dict['width'])		,    resample=__snake_case		,    data_format=__snake_case		,    **__snake_case			)







    def     lowercase_ (   self				:						List[str]		,    __snake_case				:						np.ndarray		,    __snake_case				:						Dict[str, int]		,    __snake_case				:						Optional[Union[str, ChannelDimension]] = None		,    **__snake_case				:						Tuple		,    ):
      a		:      Tuple       =  get_size_dict(__snake_case			)
      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(__snake_case		,    size=(size['height'], size['width'])		,    data_format=__snake_case		,    **__snake_case			)







    def     lowercase_ (   self				:						int		,    __snake_case				:						np.ndarray		,    __snake_case				:						Union[int, float]		,    __snake_case				:						Optional[Union[str, ChannelDimension]] = None		,    **__snake_case				:						int		,    ):
      return rescale(__snake_case		,    scale=__snake_case		,    data_format=__snake_case		,    **__snake_case			)







    def     lowercase_ (   self				:						Any		,    __snake_case				:						np.ndarray		,    __snake_case				:						Union[float, List[float]]		,    __snake_case				:						Union[float, List[float]]		,    __snake_case				:						Optional[Union[str, ChannelDimension]] = None		,    **__snake_case				:						List[Any]		,    ):
      return normalize(__snake_case		,    mean=__snake_case		,    std=__snake_case		,    data_format=__snake_case		,    **__snake_case			)







    def     lowercase_ (   self				:						Tuple		,    __snake_case				:						ImageInput		,    __snake_case				:						Optional[bool] = None		,    __snake_case				:						Optional[Dict[str, int]] = None		,    __snake_case				:						PILImageResampling = None		,    __snake_case				:						Optional[bool] = None		,    __snake_case				:						Optional[Dict[str, int]] = None		,    __snake_case				:						Optional[bool] = None		,    __snake_case				:						Optional[float] = None		,    __snake_case				:						Optional[bool] = None		,    __snake_case				:						Optional[Union[float, Iterable[float]]] = None		,    __snake_case				:						Optional[Union[float, Iterable[float]]] = None		,    __snake_case				:						Optional[TensorType] = None		,    __snake_case				:						ChannelDimension = ChannelDimension.FIRST		,    **__snake_case				:						int		,    ):
      a		:      Optional[int]       =  do_resize if do_resize is not None else self.do_resize
      a		:      str       =  resample if resample is not None else self.resample
      a		:      Optional[int]       =  do_center_crop if do_center_crop is not None else self.do_center_crop
      a		:      Union[str, Any]       =  do_rescale if do_rescale is not None else self.do_rescale
      a		:      Tuple       =  rescale_factor if rescale_factor is not None else self.rescale_factor
      a		:      str       =  do_normalize if do_normalize is not None else self.do_normalize
      a		:      List[Any]       =  image_mean if image_mean is not None else self.image_mean
      a		:      Any       =  image_std if image_std is not None else self.image_std

      a		:      Optional[int]       =  size if size is not None else self.size
      a		:      List[Any]       =  get_size_dict(__snake_case		,    default_to_square=__snake_case			)
      a		:      List[str]       =  crop_size if crop_size is not None else self.crop_size
      a		:      Tuple       =  get_size_dict(__snake_case		,    param_name='crop_size'			)

      a		:      str       =  make_list_of_images(__snake_case			)

      if not valid_images(__snake_case			):
        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.
      a		:      List[str]       =  [to_numpy_array(__snake_case			) for image in images]

      if do_resize:
        a		:      Union[str, Any]       =  [self.resize(__snake_case		,    __snake_case		,    __snake_case			) for image in images]

      if do_center_crop:
        a		:      List[str]       =  [self.center_crop(__snake_case		,    __snake_case			) for image in images]

      if do_rescale:
        a		:      Tuple       =  [self.rescale(__snake_case		,    __snake_case			) for image in images]

      if do_normalize:
        a		:      Optional[Any]       =  [self.normalize(__snake_case		,    __snake_case		,    __snake_case			) for image in images]

      a		:      List[str]       =  [to_channel_dimension_format(__snake_case		,    __snake_case			) for image in images]

      a		:      Any       =  {'pixel_values': images}
      return BatchFeature(data=__snake_case		,    tensor_type=__snake_case			)




'''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


lowerCAmelCase:      Any		 =		False

@skip_mps
class 							a__(      lowerCamelCase__	,				lowerCamelCase__	,				lowerCamelCase__	,				unittest.TestCase			):
    lowercase__				=					StableDiffusionAttendAndExcitePipeline
    lowercase__				=					False
    lowercase__				=					TEXT_TO_IMAGE_PARAMS
    lowercase__				=					TEXT_TO_IMAGE_BATCH_PARAMS.union({"""token_indices"""}			)
    lowercase__				=					TEXT_TO_IMAGE_IMAGE_PARAMS
    lowercase__				=					TEXT_TO_IMAGE_IMAGE_PARAMS







    @classmethod
    def     lowercase_ (   cls				:						Union[str, Any]			):
      super().setUpClass()
      torch.use_deterministic_algorithms(__snake_case			)







    @classmethod
    def     lowercase_ (   cls				:						Optional[Any]			):
      super().tearDownClass()
      torch.use_deterministic_algorithms(__snake_case			)







    def     lowercase_ (   self				:						List[Any]			):
      torch.manual_seed(0			)
      a		:      List[Any]       =  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=__snake_case		,    )
      a		:      Optional[int]       =  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			)
      a		:      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=1_28		,    )
      torch.manual_seed(0			)
      a		:      str       =  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		,    )
      a		:      Any       =  CLIPTextModel(__snake_case			)
      a		:      Tuple       =  CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'			)

      a		:      List[str]       =  {
          'unet': unet,
          'scheduler': scheduler,
          'vae': vae,
          'text_encoder': text_encoder,
          'tokenizer': tokenizer,
          'safety_checker': None,
          'feature_extractor': None,
      }

      return components







    def     lowercase_ (   self				:						str		,    __snake_case				:						Tuple		,    __snake_case				:						Optional[int]=0			):
      if str(__snake_case			).startswith('mps'			):
        a		:      Any       =  torch.manual_seed(__snake_case			)
      else:
        a		:      Any       =  torch.Generator(device=__snake_case			).manual_seed(__snake_case			)
      a		:      int       =  {
          '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     lowercase_ (   self				:						List[Any]			):
      a		:      Union[str, Any]       =  'cpu'

      a		:      Any       =  self.get_dummy_components()
      a		:      List[str]       =  self.pipeline_class(**__snake_case			)
      pipe.to(__snake_case			)
      pipe.set_progress_bar_config(disable=__snake_case			)

      a		:      Any       =  self.get_dummy_inputs(__snake_case			)
      a		:      int       =  pipe(**__snake_case			).images
      a		:      int       =  image[0, -3:, -3:, -1]

      self.assertEqual(image.shape		,    (1, 64, 64, 3)			)
      a		:      str       =  np.array(
          [0.63905364, 0.62897307, 0.48599017, 0.5133624, 0.5550048, 0.45769516, 0.50326973, 0.5023139, 0.45384496]			)
      a		:      int       =  np.abs(image_slice.flatten() - expected_slice			).max()
      self.assertLessEqual(__snake_case		,    1e-3			)







    def     lowercase_ (   self				:						Dict			):
      super().test_cpu_offload_forward_pass(expected_max_diff=5e-4			)







    def     lowercase_ (   self				:						Tuple			):
      # NOTE: Larger batch sizes cause this test to timeout, only test on smaller batches
      self._test_inference_batch_consistent(batch_sizes=[1, 2]			)







    def     lowercase_ (   self				:						Union[str, Any]			):
      self._test_inference_batch_single_identical(batch_size=2		,    expected_max_diff=7e-4			)







    def     lowercase_ (   self				:						Tuple			):
      super().test_dict_tuple_outputs_equivalent(expected_max_difference=3e-3			)







    def     lowercase_ (   self				:						str			):
      super().test_pt_np_pil_outputs_equivalent(expected_max_diff=5e-4			)







    def     lowercase_ (   self				:						Any			):
      super().test_save_load_local(expected_max_difference=5e-4			)







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

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







    @classmethod
    def     lowercase_ (   cls				:						Union[str, Any]			):
      super().setUpClass()
      torch.use_deterministic_algorithms(__snake_case			)







    @classmethod
    def     lowercase_ (   cls				:						Union[str, Any]			):
      super().tearDownClass()
      torch.use_deterministic_algorithms(__snake_case			)







    def     lowercase_ (   self				:						Union[str, Any]			):
      super().tearDown()
      gc.collect()
      torch.cuda.empty_cache()







    def     lowercase_ (   self				:						Optional[Any]			):
      a		:      List[Any]       =  torch.manual_seed(51			)

      a		:      Dict       =  StableDiffusionAttendAndExcitePipeline.from_pretrained(
          'CompVis/stable-diffusion-v1-4'		,    safety_checker=__snake_case		,    torch_dtype=torch.floataa			)
      pipe.to('cuda'			)

      a		:      Optional[Any]       =  'a painting of an elephant with glasses'
      a		:      Any       =  [5, 7]

      a		:      Tuple       =  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]

      a		:      str       =  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