import gc
import unittest

from parameterized import parameterized

from diffusers import FlaxUNetaDConditionModel
from diffusers.utils import is_flax_available
from diffusers.utils.testing_utils import load_hf_numpy, require_flax, slow


if is_flax_available():
     import jax
     import jax.numpy as jnp
@slow
@require_flax
class SCREAMING_SNAKE_CASE_		(      unittest.TestCase		):







   def 						lowerCamelCase_	(     self						:						Dict   ,   lowerCamelCase_						:						Union[str, Any]   ,   lowerCamelCase_						:						List[Any]				):





    """simple docstring"""


    return f"""gaussian_noise_s={seed}_shape={"_".join([str(UpperCamelCase_				) for s in shape]				)}.npy"""







   def 						lowerCamelCase_	(     self						:						int				):





    """simple docstring"""


    super().tearDown()
    gc.collect()







   def 						lowerCamelCase_	(     self						:						Optional[int]   ,   lowerCamelCase_						:						str=0   ,   lowerCamelCase_						:						List[Any]=(4, 4, 64, 64)   ,   lowerCamelCase_						:						Union[str, Any]=False				):





    """simple docstring"""


    UpperCamelCase			  =      jnp.bfloataa if fpaa else jnp.floataa
    UpperCamelCase			  =      jnp.array(load_hf_numpy(self.get_file_format(UpperCamelCase_   ,   UpperCamelCase_				)				)   ,   dtype=UpperCamelCase_				)
    return image







   def 						lowerCamelCase_	(     self						:						Tuple   ,   lowerCamelCase_						:						Any=False   ,   lowerCamelCase_						:						List[str]="CompVis/stable-diffusion-v1-4"				):





    """simple docstring"""


    UpperCamelCase			  =      jnp.bfloataa if fpaa else jnp.floataa
    UpperCamelCase			  =      'bf16' if fpaa else None

    UpperCamelCase			  =      FlaxUNetaDConditionModel.from_pretrained(
        UpperCamelCase_   ,   subfolder="""unet"""   ,   dtype=UpperCamelCase_   ,   revision=UpperCamelCase_				)
    return model, params







   def 						lowerCamelCase_	(     self						:						List[Any]   ,   lowerCamelCase_						:						Optional[int]=0   ,   lowerCamelCase_						:						int=(4, 77, 768)   ,   lowerCamelCase_						:						int=False				):





    """simple docstring"""


    UpperCamelCase			  =      jnp.bfloataa if fpaa else jnp.floataa
    UpperCamelCase			  =      jnp.array(load_hf_numpy(self.get_file_format(UpperCamelCase_   ,   UpperCamelCase_				)				)   ,   dtype=UpperCamelCase_				)
    return hidden_states







   @parameterized.expand(
       [
           # fmt: off
           [83, 4, [-0.2_3_2_3, -0.1_3_0_4, 0.0_8_1_3, -0.3_0_9_3, -0.0_9_1_9, -0.1_5_7_1, -0.1_1_2_5, -0.5_8_0_6]],
           [17, 0.5_5, [-0.0_8_3_1, -0.2_4_4_3, 0.0_9_0_1, -0.0_9_1_9, 0.3_3_9_6, 0.0_1_0_3, -0.3_7_4_3, 0.0_7_0_1]],
           [8, 0.8_9, [-0.4_8_6_3, 0.0_8_5_9, 0.0_8_7_5, -0.1_6_5_8, 0.9_1_9_9, -0.0_1_1_4, 0.4_8_3_9, 0.4_6_3_9]],
           [3, 1000, [-0.5_6_4_9, 0.2_4_0_2, -0.5_5_1_8, 0.1_2_4_8, 1.1_3_2_8, -0.2_4_4_3, -0.0_3_2_5, -1.0_0_7_8]],
           # fmt: on
       ]				)
   def 						lowerCamelCase_	(     self						:						Optional[int]   ,   lowerCamelCase_						:						Union[str, Any]   ,   lowerCamelCase_						:						Any   ,   lowerCamelCase_						:						Optional[Any]				):





    """simple docstring"""


    UpperCamelCase			  =      self.get_unet_model(model_id="""CompVis/stable-diffusion-v1-4"""   ,   fpaa=UpperCamelCase_				)
    UpperCamelCase			  =      self.get_latents(UpperCamelCase_   ,   fpaa=UpperCamelCase_				)
    UpperCamelCase			  =      self.get_encoder_hidden_states(UpperCamelCase_   ,   fpaa=UpperCamelCase_				)

    UpperCamelCase			  =      model.apply(
        {"""params""": params}   ,   UpperCamelCase_   ,   jnp.array(UpperCamelCase_   ,   dtype=jnp.intaa				)   ,   encoder_hidden_states=UpperCamelCase_   ,   ).sample

    assert sample.shape == latents.shape

    UpperCamelCase			  =      jnp.asarray(jax.device_get((sample[-1, -2:, -2:, :2].flatten())				)   ,   dtype=jnp.floataa				)
    UpperCamelCase			  =      jnp.array(UpperCamelCase_   ,   dtype=jnp.floataa				)

    # Found torch (float16) and flax (bfloat16) outputs to be within this tolerance, in the same hardware
    assert jnp.allclose(UpperCamelCase_   ,   UpperCamelCase_   ,   atol=1E-2				)







   @parameterized.expand(
       [
           # fmt: off
           [83, 4, [0.1_5_1_4, 0.0_8_0_7, 0.1_6_2_4, 0.1_0_1_6, -0.1_8_9_6, 0.0_2_6_3, 0.0_6_7_7, 0.2_3_1_0]],
           [17, 0.5_5, [0.1_1_6_4, -0.0_2_1_6, 0.0_1_7_0, 0.1_5_8_9, -0.3_1_2_0, 0.1_0_0_5, -0.0_5_8_1, -0.1_4_5_8]],
           [8, 0.8_9, [-0.1_7_5_8, -0.0_1_6_9, 0.1_0_0_4, -0.1_4_1_1, 0.1_3_1_2, 0.1_1_0_3, -0.1_9_9_6, 0.2_1_3_9]],
           [3, 1000, [0.1_2_1_4, 0.0_3_5_2, -0.0_7_3_1, -0.1_5_6_2, -0.0_9_9_4, -0.0_9_0_6, -0.2_3_4_0, -0.0_5_3_9]],
           # fmt: on
       ]				)
   def 						lowerCamelCase_	(     self						:						Tuple   ,   lowerCamelCase_						:						List[Any]   ,   lowerCamelCase_						:						Optional[Any]   ,   lowerCamelCase_						:						Optional[int]				):





    """simple docstring"""


    UpperCamelCase			  =      self.get_unet_model(model_id="""stabilityai/stable-diffusion-2"""   ,   fpaa=UpperCamelCase_				)
    UpperCamelCase			  =      self.get_latents(UpperCamelCase_   ,   shape=(4, 4, 96, 96)   ,   fpaa=UpperCamelCase_				)
    UpperCamelCase			  =      self.get_encoder_hidden_states(UpperCamelCase_   ,   shape=(4, 77, 1024)   ,   fpaa=UpperCamelCase_				)

    UpperCamelCase			  =      model.apply(
        {"""params""": params}   ,   UpperCamelCase_   ,   jnp.array(UpperCamelCase_   ,   dtype=jnp.intaa				)   ,   encoder_hidden_states=UpperCamelCase_   ,   ).sample

    assert sample.shape == latents.shape

    UpperCamelCase			  =      jnp.asarray(jax.device_get((sample[-1, -2:, -2:, :2].flatten())				)   ,   dtype=jnp.floataa				)
    UpperCamelCase			  =      jnp.array(UpperCamelCase_   ,   dtype=jnp.floataa				)

    # Found torch (float16) and flax (bfloat16) outputs to be within this tolerance, on the same hardware
    assert jnp.allclose(UpperCamelCase_   ,   UpperCamelCase_   ,   atol=1E-2				)


"""simple docstring"""



import random
import unittest

import torch

from diffusers import IFImgaImgSuperResolutionPipeline
from diffusers.utils import floats_tensor
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import skip_mps, torch_device

from ..pipeline_params import TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS, TEXT_GUIDED_IMAGE_VARIATION_PARAMS
from ..test_pipelines_common import PipelineTesterMixin
from . import IFPipelineTesterMixin





@skip_mps
class 				a			(					lowercase						,		lowercase						,		unittest.TestCase      ):
      UpperCamelCase							:   int           =     IFImgaImgSuperResolutionPipeline
      UpperCamelCase							:   Union[str, Any]           =     TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {"""width""", """height"""}
      UpperCamelCase							:   Tuple           =     TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({"""original_image"""}      )
      UpperCamelCase							:   Union[str, Any]           =     PipelineTesterMixin.required_optional_params - {"""latents"""}



      def  __snake_case							(   self      ):
          return self._get_superresolution_dummy_components()



      def  __snake_case							(   self     ,	UpperCamelCase_     ,	UpperCamelCase_=0      ):
          if str(UpperCamelCase_      ).startswith('mps'      ):
              UpperCAmelCase__	:      Optional[int]     							=					torch.manual_seed(UpperCamelCase_      )
          else:
              UpperCAmelCase__	:      int     							=					torch.Generator(device=UpperCamelCase_      ).manual_seed(UpperCamelCase_      )

          UpperCAmelCase__	:      Union[str, Any]     							=					floats_tensor((1, 3, 32, 32)     ,	rng=random.Random(UpperCamelCase_      )      ).to(UpperCamelCase_      )
          UpperCAmelCase__	:      Tuple     							=					floats_tensor((1, 3, 16, 16)     ,	rng=random.Random(UpperCamelCase_      )      ).to(UpperCamelCase_      )

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

          return inputs



      @unittest.skipIf(
          torch_device != 'cuda' or not is_xformers_available()     ,	reason='XFormers attention is only available with CUDA and `xformers` installed'     ,	)
      def  __snake_case							(   self      ):
          self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3      )



      def  __snake_case							(   self      ):
          self._test_save_load_optional_components()



      @unittest.skipIf(torch_device != 'cuda'     ,	reason='float16 requires CUDA'      )
      def  __snake_case							(   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  __snake_case							(   self      ):
          self._test_attention_slicing_forward_pass(expected_max_diff=1E-2      )



      def  __snake_case							(   self      ):
          self._test_save_load_local()



      def  __snake_case							(   self      ):
          self._test_inference_batch_single_identical(
              expected_max_diff=1E-2     ,	)

