


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 lowerCAmelCase_		(				lowerCamelCase__      ,		lowerCamelCase__      ,		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 		UpperCamelCase__  (			self      ):
       return self._get_dummy_components()



 def 		UpperCamelCase__  (			self	,   _UpperCAmelCase	,   _UpperCAmelCase=0      ):
       if str(_UpperCAmelCase      ).startswith('''mps'''      ):
             snake_case_ =   torch.manual_seed(_UpperCAmelCase      )
       else:
             snake_case_ =   torch.Generator(device=_UpperCAmelCase      ).manual_seed(_UpperCAmelCase      )

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

       return inputs



 def 		UpperCamelCase__  (			self      ):
       self._test_save_load_optional_components()



 @unittest.skipIf(torch_device != '''cuda'''	,   reason='''float16 requires CUDA'''      )
 def 		UpperCamelCase__  (			self      ):
       # Due to non-determinism in save load of the hf-internal-testing/tiny-random-t5 text encoder
       super().test_save_load_floataa(expected_max_diff=1E-1      )



 def 		UpperCamelCase__  (			self      ):
       self._test_attention_slicing_forward_pass(expected_max_diff=1E-2      )



 def 		UpperCamelCase__  (			self      ):
       self._test_save_load_local()



 def 		UpperCamelCase__  (			self      ):
       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 		UpperCamelCase__  (			self      ):
       self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3      )







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

 '''simple docstring'''

 def 		UpperCamelCase__  (			self      ):
       # clean up the VRAM after each test
       super().tearDown()
       gc.collect()
       torch.cuda.empty_cache()



 def 		UpperCamelCase__  (			self      ):
       # if

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

       snake_case_ =   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'''      )

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

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

       snake_case_ =   None
       snake_case_ =   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

       snake_case_ =   IFImgaImgPipeline(**pipe_a.components      )
       snake_case_ =   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

       snake_case_ =   IFInpaintingPipeline(**pipe_a.components      )
       snake_case_ =   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 		UpperCamelCase__  (			self	,   _UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase      ):
       # pipeline 1

       _start_torch_memory_measurement()

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

       snake_case_ =   output.images[0]

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

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

       snake_case_ =   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()

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

       snake_case_ =   floats_tensor((1, 3, 64, 64)	,   rng=random.Random(0      )      ).to(_UpperCAmelCase      )

       snake_case_ =   pipe_a(
           prompt_embeds=_UpperCAmelCase	,   negative_prompt_embeds=_UpperCAmelCase	,   image=_UpperCAmelCase	,   generator=_UpperCAmelCase	,   num_inference_steps=2	,   output_type='''np'''	,   )

       snake_case_ =   output.images[0]

       assert image.shape == (2_56, 2_56, 3)

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

       snake_case_ =   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 		UpperCamelCase__  (			self	,   _UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase      ):
       # pipeline 1

       _start_torch_memory_measurement()

       snake_case_ =   floats_tensor((1, 3, 64, 64)	,   rng=random.Random(0      )      ).to(_UpperCAmelCase      )

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

       snake_case_ =   pipe_a(
           prompt_embeds=_UpperCAmelCase	,   negative_prompt_embeds=_UpperCAmelCase	,   image=_UpperCAmelCase	,   num_inference_steps=2	,   generator=_UpperCAmelCase	,   output_type='''np'''	,   )

       snake_case_ =   output.images[0]

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

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

       snake_case_ =   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()

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

       snake_case_ =   floats_tensor((1, 3, 2_56, 2_56)	,   rng=random.Random(0      )      ).to(_UpperCAmelCase      )
       snake_case_ =   floats_tensor((1, 3, 64, 64)	,   rng=random.Random(0      )      ).to(_UpperCAmelCase      )

       snake_case_ =   pipe_a(
           prompt_embeds=_UpperCAmelCase	,   negative_prompt_embeds=_UpperCAmelCase	,   image=_UpperCAmelCase	,   original_image=_UpperCAmelCase	,   generator=_UpperCAmelCase	,   num_inference_steps=2	,   output_type='''np'''	,   )

       snake_case_ =   output.images[0]

       assert image.shape == (2_56, 2_56, 3)

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

       snake_case_ =   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 		UpperCamelCase__  (			self	,   _UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase      ):
       # pipeline 1

       _start_torch_memory_measurement()

       snake_case_ =   floats_tensor((1, 3, 64, 64)	,   rng=random.Random(0      )      ).to(_UpperCAmelCase      )
       snake_case_ =   floats_tensor((1, 3, 64, 64)	,   rng=random.Random(1      )      ).to(_UpperCAmelCase      )

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

       snake_case_ =   output.images[0]

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

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

       snake_case_ =   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()

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

       snake_case_ =   floats_tensor((1, 3, 64, 64)	,   rng=random.Random(0      )      ).to(_UpperCAmelCase      )
       snake_case_ =   floats_tensor((1, 3, 2_56, 2_56)	,   rng=random.Random(0      )      ).to(_UpperCAmelCase      )
       snake_case_ =   floats_tensor((1, 3, 2_56, 2_56)	,   rng=random.Random(1      )      ).to(_UpperCAmelCase      )

       snake_case_ =   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'''	,   )

       snake_case_ =   output.images[0]

       assert image.shape == (2_56, 2_56, 3)

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

       snake_case_ =   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  __lowerCAmelCase					()->						Optional[int]:




      """simple docstring"""

      torch.cuda.empty_cache()
      torch.cuda.reset_max_memory_allocated()
      torch.cuda.reset_peak_memory_stats()



from math import sqrt

import numpy as np
from sympy import symbols

# Coefficient
# Speed of light (m/s)
UpperCAmelCase    =					2_9979_2458

# Symbols
UpperCAmelCase,							UpperCAmelCase,							UpperCAmelCase,							UpperCAmelCase    =					symbols("""ct x y z""")






def  __lowerCAmelCase					(SCREAMING_SNAKE_CASE      )->						float:




      """simple docstring"""

      if velocity > c:
            raise ValueError('''Speed must not exceed light speed 299,792,458 [m/s]!'''      )
      elif velocity < 1:
            # Usually the speed should be much higher than 1 (c order of magnitude)
            raise ValueError('''Speed must be greater than or equal to 1!'''      )

      return velocity / c






def  __lowerCAmelCase					(SCREAMING_SNAKE_CASE      )->						float:




      """simple docstring"""

      return 1 / sqrt(1 - beta(SCREAMING_SNAKE_CASE      ) ** 2      )






def  __lowerCAmelCase					(SCREAMING_SNAKE_CASE      )->						np.ndarray:




      """simple docstring"""

      return np.array(
          [
              [gamma(SCREAMING_SNAKE_CASE      ), -gamma(SCREAMING_SNAKE_CASE      ) * beta(SCREAMING_SNAKE_CASE      ), 0, 0],
              [-gamma(SCREAMING_SNAKE_CASE      ) * beta(SCREAMING_SNAKE_CASE      ), gamma(SCREAMING_SNAKE_CASE      ), 0, 0],
              [0, 0, 1, 0],
              [0, 0, 0, 1],
          ]      )






def  __lowerCAmelCase					(SCREAMING_SNAKE_CASE      ,      SCREAMING_SNAKE_CASE = None      )->						np.ndarray:




      """simple docstring"""

      if event is None:
            snake_case_ =   np.array([ct, x, y, z]      )  # Symbolic four vector
      else:
            event[0] *= c  # x0 is ct (speed of light * time)

      return transformation_matrix(SCREAMING_SNAKE_CASE      ) @ event


if __name__ == "__main__":
   import doctest

   doctest.testmod()

   # Example of symbolic vector:
   UpperCAmelCase    =					transform(2997_9245)
   print("""Example of four vector: """)
   print(f'''ct\' = {four_vector[0]}''')
   print(f'''x\' = {four_vector[1]}''')
   print(f'''y\' = {four_vector[2]}''')
   print(f'''z\' = {four_vector[3]}''')

   # Substitute symbols with numerical values
   UpperCAmelCase    =					{ct: c, x: 1, y: 1, z: 1}
   UpperCAmelCase    =					[four_vector[i].subs(sub_dict) for i in range(4)]

   print(f'''\n{numerical_vector}''')