




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


_UpperCAmelCase        =				False



@skip_mps
class 							_UpperCamelCase					(	lowerCAmelCase_  ,						lowerCAmelCase_  ,						lowerCAmelCase_  ,						unittest.TestCase     ):
       _UpperCamelCase				:					Union[str, Any]         =   StableDiffusionAttendAndExcitePipeline
       _UpperCamelCase				:					Any         =   False
       _UpperCamelCase				:					int         =   TEXT_TO_IMAGE_PARAMS
       _UpperCamelCase				:					Any         =   TEXT_TO_IMAGE_BATCH_PARAMS.union({'''token_indices'''}     )
       _UpperCamelCase				:					List[Any]         =   TEXT_TO_IMAGE_IMAGE_PARAMS
       _UpperCamelCase				:					List[Any]         =   TEXT_TO_IMAGE_IMAGE_PARAMS

       @classmethod
       def lowercase (		cls: Any		)       -> Tuple:




              """simple docstring"""


              super().setUpClass()
              torch.use_deterministic_algorithms(_SCREAMING_SNAKE_CASE		)

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




              """simple docstring"""


              super().tearDownClass()
              torch.use_deterministic_algorithms(_SCREAMING_SNAKE_CASE		)

       def lowercase (		self: int		)       -> str:




              """simple docstring"""


              torch.manual_seed(0		)
              UpperCamelCase_          =  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=_SCREAMING_SNAKE_CASE					,   )
              UpperCamelCase_          =  DDIMScheduler(
                  beta_start=0.0_00_85					,   beta_end=0.0_12					,   beta_schedule="scaled_linear"					,   clip_sample=_SCREAMING_SNAKE_CASE					,   set_alpha_to_one=_SCREAMING_SNAKE_CASE					,   )
              torch.manual_seed(0		)
              UpperCamelCase_          =  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		)
              UpperCamelCase_          =  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					,   )
              UpperCamelCase_          =  CLIPTextModel(_SCREAMING_SNAKE_CASE		)
              UpperCamelCase_          =  CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"		)

              UpperCamelCase_          =  {
                  "unet": unet,
                  "scheduler": scheduler,
                  "vae": vae,
                  "text_encoder": text_encoder,
                  "tokenizer": tokenizer,
                  "safety_checker": None,
                  "feature_extractor": None,
              }

              return components

       def lowercase (		self: Dict					,   _SCREAMING_SNAKE_CASE: Optional[int]					,   _SCREAMING_SNAKE_CASE: Any=0		)       -> Any:




              """simple docstring"""


              if str(_SCREAMING_SNAKE_CASE		).startswith("mps"		):
                     UpperCamelCase_          =  torch.manual_seed(_SCREAMING_SNAKE_CASE		)
              else:
                     UpperCamelCase_          =  torch.Generator(device=_SCREAMING_SNAKE_CASE		).manual_seed(_SCREAMING_SNAKE_CASE		)
              UpperCamelCase_          =  UpperCamelCase_          =  {
                  "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: Tuple		)       -> List[str]:




              """simple docstring"""


              UpperCamelCase_          =  "cpu"

              UpperCamelCase_          =  self.get_dummy_components()
              UpperCamelCase_          =  self.pipeline_class(**_SCREAMING_SNAKE_CASE		)
              pipe.to(_SCREAMING_SNAKE_CASE		)
              pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE		)

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

              self.assertEqual(image.shape					,   (1, 64, 64, 3)		)
              UpperCamelCase_          =  np.array(
                  [0.63_90_53_64, 0.62_89_73_07, 0.48_59_90_17, 0.5_13_36_24, 0.5_55_00_48, 0.45_76_95_16, 0.50_32_69_73, 0.5_02_31_39, 0.45_38_44_96]		)
              UpperCamelCase_          =  np.abs(image_slice.flatten() - expected_slice		).max()
              self.assertLessEqual(_SCREAMING_SNAKE_CASE					,   1e-3		)

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




              """simple docstring"""


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

       def lowercase (		self: Tuple		)       -> Optional[int]:




              """simple docstring"""


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

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




              """simple docstring"""


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

       def lowercase (		self: Dict		)       -> List[Any]:




              """simple docstring"""


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

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




              """simple docstring"""


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

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




              """simple docstring"""


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



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




              """simple docstring"""


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



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

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




              """simple docstring"""


              super().setUpClass()
              torch.use_deterministic_algorithms(_SCREAMING_SNAKE_CASE		)

       @classmethod
       def lowercase (		cls: List[Any]		)       -> int:




              """simple docstring"""


              super().tearDownClass()
              torch.use_deterministic_algorithms(_SCREAMING_SNAKE_CASE		)

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




              """simple docstring"""


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



       def lowercase (		self: Optional[int]		)       -> Dict:




              """simple docstring"""


              UpperCamelCase_          =  torch.manual_seed(51		)

              UpperCamelCase_          =  StableDiffusionAttendAndExcitePipeline.from_pretrained(
                  "CompVis/stable-diffusion-v1-4"					,   safety_checker=_SCREAMING_SNAKE_CASE					,   torch_dtype=torch.floataa		)
              pipe.to("cuda"		)

              UpperCamelCase_          =  "a painting of an elephant with glasses"
              UpperCamelCase_          =  [5, 7]

              UpperCamelCase_          =  pipe(
                  prompt=_SCREAMING_SNAKE_CASE					,   token_indices=_SCREAMING_SNAKE_CASE					,   guidance_scale=7.5					,   generator=_SCREAMING_SNAKE_CASE					,   num_inference_steps=5					,   max_iter_to_alter=5					,   output_type="numpy"					,   ).images[0]

              UpperCamelCase_          =  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








import random
from typing import Any




def  lowerCAmelCase_ (							UpperCamelCase_  )     ->		list[Any]:
       for _ in range(len(UpperCamelCase_  )  ):
              UpperCamelCase_          =  random.randint(0					,		len(UpperCamelCase_  ) - 1  )
              UpperCamelCase_          =  random.randint(0					,		len(UpperCamelCase_  ) - 1  )
              UpperCamelCase_       , UpperCamelCase_          =  data[b], data[a]
       return data


if __name__ == "__main__":
     _UpperCAmelCase        =				[0, 1, 2, 3, 4, 5, 6, 7]
     _UpperCAmelCase        =				['python', 'says', 'hello', '!']
     print('Fisher-Yates Shuffle:')
     print('List', integers, strings)
     print('FY Shuffle', fisher_yates_shuffle(integers), fisher_yates_shuffle(strings))

