



import gc
import unittest

import numpy as np
import torch

from diffusers import RePaintPipeline, RePaintScheduler, UNetaDModel
from diffusers.utils.testing_utils import (
    enable_full_determinism,
    load_image,
    load_numpy,
    nightly,
    require_torch_gpu,
    skip_mps,
    torch_device,
)

from ..pipeline_params import IMAGE_INPAINTING_BATCH_PARAMS, IMAGE_INPAINTING_PARAMS
from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()







class    lowerCamelCase__     ( lowerCAmelCase     ,							unittest.TestCase):
     SCREAMING_SNAKE_CASE__       =    RePaintPipeline
     SCREAMING_SNAKE_CASE__       =    IMAGE_INPAINTING_PARAMS - {'''width''', '''height''', '''guidance_scale'''}
     SCREAMING_SNAKE_CASE__       =    PipelineTesterMixin.required_optional_params - {
         '''latents''',
         '''num_images_per_prompt''',
         '''callback''',
         '''callback_steps''',
     }
     SCREAMING_SNAKE_CASE__       =    IMAGE_INPAINTING_BATCH_PARAMS
     SCREAMING_SNAKE_CASE__       =    False





     def   __A      (self )  ->     Optional[int]:
      torch.manual_seed(0 )
      torch.manual_seed(0 )
      _lowercase							   =UNetaDModel(
          block_out_channels=(3_2, 6_4)	,  layers_per_block=2	,  sample_size=3_2	,  in_channels=3	,  out_channels=3	,  down_block_types=('''DownBlock2D''', '''AttnDownBlock2D''')	,  up_block_types=('''AttnUpBlock2D''', '''UpBlock2D''')	,  )
      _lowercase							   =RePaintScheduler()
      _lowercase							   ={'''unet''': unet, '''scheduler''': scheduler}
      return components





     def   __A      (self	,  UpperCAmelCase	,  UpperCAmelCase=0 )  ->     List[Any]:
      if str(UpperCAmelCase ).startswith('''mps''' ):
       _lowercase							   =torch.manual_seed(UpperCAmelCase )
      else:
       _lowercase							   =torch.Generator(device=UpperCAmelCase ).manual_seed(UpperCAmelCase )
      _lowercase							   =np.random.RandomState(UpperCAmelCase ).standard_normal((1, 3, 3_2, 3_2) )
      _lowercase							   =torch.from_numpy(UpperCAmelCase ).to(device=UpperCAmelCase	,  dtype=torch.floataa )
      _lowercase							   =(image > 0).to(device=UpperCAmelCase	,  dtype=torch.floataa )
      _lowercase							   ={
          '''image''': image,
          '''mask_image''': mask,
          '''generator''': generator,
          '''num_inference_steps''': 5,
          '''eta''': 0.0,
          '''jump_length''': 2,
          '''jump_n_sample''': 2,
          '''output_type''': '''numpy''',
      }
      return inputs





     def   __A      (self )  ->     int:
      _lowercase							   ='''cpu'''  # ensure determinism for the device-dependent torch.Generator
      _lowercase							   =self.get_dummy_components()
      _lowercase							   =RePaintPipeline(**UpperCAmelCase )
      _lowercase							   =sd_pipe.to(UpperCAmelCase )
      sd_pipe.set_progress_bar_config(disable=UpperCAmelCase )

      _lowercase							   =self.get_dummy_inputs(UpperCAmelCase )
      _lowercase							   =sd_pipe(**UpperCAmelCase ).images
      _lowercase							   =image[0, -3:, -3:, -1]

      assert image.shape == (1, 3_2, 3_2, 3)
      _lowercase							   =np.array([1.0000, 0.5426, 0.5497, 0.2200, 1.0000, 1.0000, 0.5623, 1.0000, 0.6274] )

      assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-3





     @skip_mps
     def   __A      (self )  ->     Optional[int]:
      return super().test_save_load_local()





     @unittest.skip('''non-deterministic pipeline''' )
     def   __A      (self )  ->     int:
      return super().test_inference_batch_single_identical()





     @skip_mps
     def   __A      (self )  ->     Union[str, Any]:
      return super().test_dict_tuple_outputs_equivalent()





     @skip_mps
     def   __A      (self )  ->     Optional[int]:
      return super().test_save_load_optional_components()





     @skip_mps
     def   __A      (self )  ->     Union[str, Any]:
      return super().test_attention_slicing_forward_pass()







@nightly
@require_torch_gpu
class    lowerCamelCase__     ( unittest.TestCase):





     def   __A      (self )  ->     Union[str, Any]:
      super().tearDown()
      gc.collect()
      torch.cuda.empty_cache()





     def   __A      (self )  ->     int:
      _lowercase							   =load_image(
          '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/'''
          '''repaint/celeba_hq_256.png''' )
      _lowercase							   =load_image(
          '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/repaint/mask_256.png''' )
      _lowercase							   =load_numpy(
          '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/'''
          '''repaint/celeba_hq_256_result.npy''' )

      _lowercase							   ='''google/ddpm-ema-celebahq-256'''
      _lowercase							   =UNetaDModel.from_pretrained(UpperCAmelCase )
      _lowercase							   =RePaintScheduler.from_pretrained(UpperCAmelCase )

      _lowercase							   =RePaintPipeline(unet=UpperCAmelCase	,  scheduler=UpperCAmelCase ).to(UpperCAmelCase )
      repaint.set_progress_bar_config(disable=UpperCAmelCase )
      repaint.enable_attention_slicing()

      _lowercase							   =torch.manual_seed(0 )
      _lowercase							   =repaint(
          UpperCAmelCase	,  UpperCAmelCase	,  num_inference_steps=2_5_0	,  eta=0.0	,  jump_length=1_0	,  jump_n_sample=1_0	,  generator=UpperCAmelCase	,  output_type='''np'''	,  )
      _lowercase							   =output.images[0]

      assert image.shape == (2_5_6, 2_5_6, 3)
      assert np.abs(expected_image - image ).mean() < 1e-2





import unittest

import numpy as np

from transformers import is_tf_available
from transformers.testing_utils import require_tf


if is_tf_available():
  import tensorflow as tf

  from transformers.activations_tf import get_tf_activation







@require_tf
class    lowerCamelCase__     ( unittest.TestCase):





     def   __A      (self )  ->     Optional[Any]:
      _lowercase							   =tf.constant([-1_0_0, -1.0, -0.1, 0, 0.1, 1.0, 100.0] )
      _lowercase							   =get_tf_activation('''gelu''' )
      _lowercase							   =get_tf_activation('''gelu_10''' )

      _lowercase							   =gelu(UpperCAmelCase )
      _lowercase							   =geluaa(UpperCAmelCase )

      _lowercase							   =tf.where(y_gelu_aa < 10.0	,  1.0	,  0.0 )

      self.assertEqual(tf.math.reduce_max(UpperCAmelCase ).numpy().item()	,  10.0 )
      self.assertTrue(np.allclose(y_gelu * clipped_mask	,  y_gelu_aa * clipped_mask ) )





     def   __A      (self )  ->     Optional[Any]:
      get_tf_activation('''gelu''' )
      get_tf_activation('''gelu_10''' )
      get_tf_activation('''gelu_fast''' )
      get_tf_activation('''gelu_new''' )
      get_tf_activation('''glu''' )
      get_tf_activation('''mish''' )
      get_tf_activation('''quick_gelu''' )
      get_tf_activation('''relu''' )
      get_tf_activation('''sigmoid''' )
      get_tf_activation('''silu''' )
      get_tf_activation('''swish''' )
      get_tf_activation('''tanh''' )
      with self.assertRaises(UpperCAmelCase ):
       get_tf_activation('''bogus''' )
      with self.assertRaises(UpperCAmelCase ):
       get_tf_activation(UpperCAmelCase )

