






import gc
import random
import unittest

import torch

from diffusers import (
    IFImgaImgPipeline,
    IFImgaImgSuperResolutionPipeline,
    IFInpaintingPipeline,
    IFInpaintingSuperResolutionPipeline,
    IFPipeline,
    IFSuperResolutionPipeline,
)
from diffusers.models.attention_processor import AttnAddedKVProcessor
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import floats_tensor, load_numpy, require_torch_gpu, skip_mps, slow, torch_device

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference
from . import IFPipelineTesterMixin






@skip_mps
class 						lowercase_   (      lowercase					,    lowercase					,    unittest.TestCase  ):






      '''simple docstring'''




      __snake_case	    =    IFPipeline
      __snake_case	    =    TEXT_TO_IMAGE_PARAMS - {'''width''', '''height''', '''latents'''}
      __snake_case	    =    TEXT_TO_IMAGE_BATCH_PARAMS
      __snake_case	    =    PipelineTesterMixin.required_optional_params - {'''latents'''}







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




       """simple docstring"""


       return self._get_dummy_components()







      def  __lowerCAmelCase   ( self :		Dict					,   __UpperCAmelCase :		Optional[int]					,   __UpperCAmelCase :		List[Any]=0    )       ->Any:




       """simple docstring"""


       if str(__UpperCAmelCase    ).startswith('''mps'''    ):
        a						    = torch.manual_seed(__UpperCAmelCase    )
       else:
        a						    = torch.Generator(device=__UpperCAmelCase    ).manual_seed(__UpperCAmelCase    )

       a						    = {
           '''prompt''': '''A painting of a squirrel eating a burger''',
           '''generator''': generator,
           '''num_inference_steps''': 2,
           '''output_type''': '''numpy''',
       }

       return inputs







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




       """simple docstring"""


       self._test_save_load_optional_components()







      @unittest.skipIf(torch_device != '''cuda'''					,   reason='''float16 requires CUDA'''    )
      def  __lowerCAmelCase   ( self :		Any    )       ->int:




       """simple docstring"""


       super().test_save_load_floataa(expected_max_diff=1e-1    )







      def  __lowerCAmelCase   ( self :		List[Any]    )       ->List[Any]:




       """simple docstring"""


       self._test_attention_slicing_forward_pass(expected_max_diff=1e-2    )







      def  __lowerCAmelCase   ( self :		Optional[Any]    )       ->Dict:




       """simple docstring"""


       self._test_save_load_local()







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




       """simple docstring"""


       self._test_inference_batch_single_identical(
           expected_max_diff=1e-2					,   )







      @unittest.skipIf(
          torch_device != '''cuda''' or not is_xformers_available()					,   reason='''XFormers attention is only available with CUDA and `xformers` installed'''					,   )
      def  __lowerCAmelCase   ( self :		int    )       ->Tuple:




       """simple docstring"""


       self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1e-3    )






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






      '''simple docstring'''




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




       """simple docstring"""


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







      def  __lowerCAmelCase   ( self :		str    )       ->Tuple:




       """simple docstring"""


       a						    = IFPipeline.from_pretrained('''DeepFloyd/IF-I-XL-v1.0'''					,   variant='''fp16'''					,   torch_dtype=torch.floataa    )

       a						    = IFSuperResolutionPipeline.from_pretrained(
           '''DeepFloyd/IF-II-L-v1.0'''					,   variant='''fp16'''					,   torch_dtype=torch.floataa					,   text_encoder=__UpperCAmelCase					,   tokenizer=__UpperCAmelCase    )

       # pre compute text embeddings and remove T5 to save memory

       pipe_a.text_encoder.to('''cuda'''    )

       a    ,	a						    = pipe_a.encode_prompt('''anime turtle'''					,   device='''cuda'''    )

       del pipe_a.tokenizer
       del pipe_a.text_encoder
       gc.collect()

       a						    = None
       a						    = None

       pipe_a.enable_model_cpu_offload()
       pipe_a.enable_model_cpu_offload()

       pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()    )
       pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()    )

       self._test_if(__UpperCAmelCase					,   __UpperCAmelCase					,   __UpperCAmelCase					,   __UpperCAmelCase    )

       pipe_a.remove_all_hooks()
       pipe_a.remove_all_hooks()

       # img2img

       a						    = IFImgaImgPipeline(**pipe_a.components    )
       a						    = IFImgaImgSuperResolutionPipeline(**pipe_a.components    )

       pipe_a.enable_model_cpu_offload()
       pipe_a.enable_model_cpu_offload()

       pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()    )
       pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()    )

       self._test_if_imgaimg(__UpperCAmelCase					,   __UpperCAmelCase					,   __UpperCAmelCase					,   __UpperCAmelCase    )

       pipe_a.remove_all_hooks()
       pipe_a.remove_all_hooks()

       # inpainting

       a						    = IFInpaintingPipeline(**pipe_a.components    )
       a						    = IFInpaintingSuperResolutionPipeline(**pipe_a.components    )

       pipe_a.enable_model_cpu_offload()
       pipe_a.enable_model_cpu_offload()

       pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()    )
       pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()    )

       self._test_if_inpainting(__UpperCAmelCase					,   __UpperCAmelCase					,   __UpperCAmelCase					,   __UpperCAmelCase    )







      def  __lowerCAmelCase   ( self :		Dict					,   __UpperCAmelCase :		List[str]					,   __UpperCAmelCase :		int					,   __UpperCAmelCase :		str					,   __UpperCAmelCase :		Optional[Any]    )       ->Dict:




       """simple docstring"""


       _start_torch_memory_measurement()

       a						    = torch.Generator(device='''cpu'''    ).manual_seed(0    )
       a						    = pipe_a(
           prompt_embeds=__UpperCAmelCase					,   negative_prompt_embeds=__UpperCAmelCase					,   num_inference_steps=2					,   generator=__UpperCAmelCase					,   output_type='''np'''					,   )

       a						    = output.images[0]

       assert image.shape == (64, 64, 3)

       a						    = torch.cuda.max_memory_allocated()
       assert mem_bytes < 13 * 10**9

       a						    = load_numpy(
           '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if.npy'''    )
       assert_mean_pixel_difference(__UpperCAmelCase					,   __UpperCAmelCase    )

       # pipeline 2

       _start_torch_memory_measurement()

       a						    = torch.Generator(device='''cpu'''    ).manual_seed(0    )

       a						    = floats_tensor((1, 3, 64, 64)					,   rng=random.Random(0    )    ).to(__UpperCAmelCase    )

       a						    = pipe_a(
           prompt_embeds=__UpperCAmelCase					,   negative_prompt_embeds=__UpperCAmelCase					,   image=__UpperCAmelCase					,   generator=__UpperCAmelCase					,   num_inference_steps=2					,   output_type='''np'''					,   )

       a						    = output.images[0]

       assert image.shape == (256, 256, 3)

       a						    = torch.cuda.max_memory_allocated()
       assert mem_bytes < 4 * 10**9

       a						    = load_numpy(
           '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_superresolution_stage_II.npy'''    )
       assert_mean_pixel_difference(__UpperCAmelCase					,   __UpperCAmelCase    )







      def  __lowerCAmelCase   ( self :		Optional[Any]					,   __UpperCAmelCase :		List[Any]					,   __UpperCAmelCase :		Dict					,   __UpperCAmelCase :		Union[str, Any]					,   __UpperCAmelCase :		List[str]    )       ->int:




       """simple docstring"""


       _start_torch_memory_measurement()

       a						    = floats_tensor((1, 3, 64, 64)					,   rng=random.Random(0    )    ).to(__UpperCAmelCase    )

       a						    = torch.Generator(device='''cpu'''    ).manual_seed(0    )

       a						    = pipe_a(
           prompt_embeds=__UpperCAmelCase					,   negative_prompt_embeds=__UpperCAmelCase					,   image=__UpperCAmelCase					,   num_inference_steps=2					,   generator=__UpperCAmelCase					,   output_type='''np'''					,   )

       a						    = output.images[0]

       assert image.shape == (64, 64, 3)

       a						    = torch.cuda.max_memory_allocated()
       assert mem_bytes < 10 * 10**9

       a						    = load_numpy(
           '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_img2img.npy'''    )
       assert_mean_pixel_difference(__UpperCAmelCase					,   __UpperCAmelCase    )

       # pipeline 2

       _start_torch_memory_measurement()

       a						    = torch.Generator(device='''cpu'''    ).manual_seed(0    )

       a						    = floats_tensor((1, 3, 256, 256)					,   rng=random.Random(0    )    ).to(__UpperCAmelCase    )
       a						    = floats_tensor((1, 3, 64, 64)					,   rng=random.Random(0    )    ).to(__UpperCAmelCase    )

       a						    = pipe_a(
           prompt_embeds=__UpperCAmelCase					,   negative_prompt_embeds=__UpperCAmelCase					,   image=__UpperCAmelCase					,   original_image=__UpperCAmelCase					,   generator=__UpperCAmelCase					,   num_inference_steps=2					,   output_type='''np'''					,   )

       a						    = output.images[0]

       assert image.shape == (256, 256, 3)

       a						    = torch.cuda.max_memory_allocated()
       assert mem_bytes < 4 * 10**9

       a						    = load_numpy(
           '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_img2img_superresolution_stage_II.npy'''    )
       assert_mean_pixel_difference(__UpperCAmelCase					,   __UpperCAmelCase    )







      def  __lowerCAmelCase   ( self :		List[str]					,   __UpperCAmelCase :		Any					,   __UpperCAmelCase :		List[Any]					,   __UpperCAmelCase :		str					,   __UpperCAmelCase :		List[str]    )       ->List[Any]:




       """simple docstring"""


       _start_torch_memory_measurement()

       a						    = floats_tensor((1, 3, 64, 64)					,   rng=random.Random(0    )    ).to(__UpperCAmelCase    )
       a						    = floats_tensor((1, 3, 64, 64)					,   rng=random.Random(1    )    ).to(__UpperCAmelCase    )

       a						    = torch.Generator(device='''cpu'''    ).manual_seed(0    )
       a						    = pipe_a(
           prompt_embeds=__UpperCAmelCase					,   negative_prompt_embeds=__UpperCAmelCase					,   image=__UpperCAmelCase					,   mask_image=__UpperCAmelCase					,   num_inference_steps=2					,   generator=__UpperCAmelCase					,   output_type='''np'''					,   )

       a						    = output.images[0]

       assert image.shape == (64, 64, 3)

       a						    = torch.cuda.max_memory_allocated()
       assert mem_bytes < 10 * 10**9

       a						    = load_numpy(
           '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_inpainting.npy'''    )
       assert_mean_pixel_difference(__UpperCAmelCase					,   __UpperCAmelCase    )

       # pipeline 2

       _start_torch_memory_measurement()

       a						    = torch.Generator(device='''cpu'''    ).manual_seed(0    )

       a						    = floats_tensor((1, 3, 64, 64)					,   rng=random.Random(0    )    ).to(__UpperCAmelCase    )
       a						    = floats_tensor((1, 3, 256, 256)					,   rng=random.Random(0    )    ).to(__UpperCAmelCase    )
       a						    = floats_tensor((1, 3, 256, 256)					,   rng=random.Random(1    )    ).to(__UpperCAmelCase    )

       a						    = pipe_a(
           prompt_embeds=__UpperCAmelCase					,   negative_prompt_embeds=__UpperCAmelCase					,   image=__UpperCAmelCase					,   mask_image=__UpperCAmelCase					,   original_image=__UpperCAmelCase					,   generator=__UpperCAmelCase					,   num_inference_steps=2					,   output_type='''np'''					,   )

       a						    = output.images[0]

       assert image.shape == (256, 256, 3)

       a						    = torch.cuda.max_memory_allocated()
       assert mem_bytes < 4 * 10**9

       a						    = load_numpy(
           '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_inpainting_superresolution_stage_II.npy'''    )
       assert_mean_pixel_difference(__UpperCAmelCase					,   __UpperCAmelCase    )
def 		_a       ( )				->     str:
 torch.cuda.empty_cache()
 torch.cuda.reset_max_memory_allocated()
 torch.cuda.reset_peak_memory_stats()










from typing import Any

import numpy as np
def 		_a       ( a					:np.ndarray					)				->     bool:
 return np.array_equal(a      ,				matrix.conjugate().T					)
def 		_a       ( a					:np.ndarray      ,				a					:np.ndarray					)				->     Any:
 a						    = v.conjugate().T
 a						    = v_star.dot(a					)
 assert isinstance(a      ,				np.ndarray					)
 return (v_star_dot.dot(a					)) / (v_star.dot(a					))
def 		_a       ( )				->     None:
 a						    = np.array([[2, 2 + 1j, 4], [2 - 1j, 3, 1j], [4, -1j, 1]]					)
 a						    = np.array([[1], [2], [3]]					)
 assert is_hermitian(a					), F"""{a} is not hermitian."""
 print(rayleigh_quotient(a      ,				a					)					)

 a						    = np.array([[1, 2, 4], [2, 3, -1], [4, -1, 1]]					)
 assert is_hermitian(a					), F"""{a} is not hermitian."""
 assert rayleigh_quotient(a      ,				a					) == float(3					)


if __name__ == "__main__":
     import doctest

     doctest.testmod()
     tests()


