


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     __UpperCAmelCase							(       unittest.TestCase							):


     """simple docstring"""


     def 	snake_case_  (	self  ,       __A  ,       __A    ):
        return f'''gaussian_noise_s={seed}_shape={'_'.join([str(__A    ) for s in shape]    )}.npy'''


     def 	snake_case_  (	self    ):
        # clean up the VRAM after each test
        super().tearDown()
        gc.collect()


     def 	snake_case_  (	self  ,       __A=0  ,       __A=(4, 4, 64, 64)  ,       __A=False    ):
        __a					=  jnp.bfloataa if fpaa else jnp.floataa
        __a					=  jnp.array(load_hf_numpy(self.get_file_format(__A  ,       __A    )    )  ,       dtype=__A    )
        return image


     def 	snake_case_  (	self  ,       __A=False  ,       __A="CompVis/stable-diffusion-v1-4"    ):
        __a					=  jnp.bfloataa if fpaa else jnp.floataa
        __a					=  """bf16""" if fpaa else None

        __a	,    __a					=  FlaxUNetaDConditionModel.from_pretrained(
            __A  ,       subfolder="""unet"""  ,       dtype=__A  ,       revision=__A    )
        return model, params


     def 	snake_case_  (	self  ,       __A=0  ,       __A=(4, 77, 768)  ,       __A=False    ):
        __a					=  jnp.bfloataa if fpaa else jnp.floataa
        __a					=  jnp.array(load_hf_numpy(self.get_file_format(__A  ,       __A    )    )  ,       dtype=__A    )
        return hidden_states


     @parameterized.expand(
         [
             # fmt: off
             [83, 4, [-0.2323, -0.1304, 0.0813, -0.3093, -0.0919, -0.1571, -0.1125, -0.5806]],
             [17, 0.55, [-0.0831, -0.2443, 0.0901, -0.0919, 0.3396, 0.0103, -0.3743, 0.0701]],
             [8, 0.89, [-0.4863, 0.0859, 0.0875, -0.1658, 0.9199, -0.0114, 0.4839, 0.4639]],
             [3, 1000, [-0.5649, 0.2402, -0.5518, 0.1248, 1.1328, -0.2443, -0.0325, -1.0078]],
             # fmt: on
         ]    )
     def 	snake_case_  (	self  ,       __A  ,       __A  ,       __A    ):
        __a	,    __a					=  self.get_unet_model(model_id="""CompVis/stable-diffusion-v1-4"""  ,       fpaa=__A    )
        __a					=  self.get_latents(__A  ,       fpaa=__A    )
        __a					=  self.get_encoder_hidden_states(__A  ,       fpaa=__A    )

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

        assert sample.shape == latents.shape

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

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


     @parameterized.expand(
         [
             # fmt: off
             [83, 4, [0.1514, 0.0807, 0.1624, 0.1016, -0.1896, 0.0263, 0.0677, 0.2310]],
             [17, 0.55, [0.1164, -0.0216, 0.0170, 0.1589, -0.3120, 0.1005, -0.0581, -0.1458]],
             [8, 0.89, [-0.1758, -0.0169, 0.1004, -0.1411, 0.1312, 0.1103, -0.1996, 0.2139]],
             [3, 1000, [0.1214, 0.0352, -0.0731, -0.1562, -0.0994, -0.0906, -0.2340, -0.0539]],
             # fmt: on
         ]    )
     def 	snake_case_  (	self  ,       __A  ,       __A  ,       __A    ):
        __a	,    __a					=  self.get_unet_model(model_id="""stabilityai/stable-diffusion-2"""  ,       fpaa=__A    )
        __a					=  self.get_latents(__A  ,       shape=(4, 4, 96, 96)  ,       fpaa=__A    )
        __a					=  self.get_encoder_hidden_states(__A  ,       shape=(4, 77, 1024)  ,       fpaa=__A    )

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

        assert sample.shape == latents.shape

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

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





from ...utils import (
    OptionalDependencyNotAvailable,
    is_flax_available,
    is_torch_available,
    is_transformers_available,
)


try:
 if not (is_transformers_available() and is_torch_available()):
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 from ...utils.dummy_torch_and_transformers_objects import *  # noqa F403
else:
 from .multicontrolnet import MultiControlNetModel
 from .pipeline_controlnet import StableDiffusionControlNetPipeline
 from .pipeline_controlnet_imgaimg import StableDiffusionControlNetImgaImgPipeline
 from .pipeline_controlnet_inpaint import StableDiffusionControlNetInpaintPipeline


if is_transformers_available() and is_flax_available():
 from .pipeline_flax_controlnet import FlaxStableDiffusionControlNetPipeline


