






'''simple docstring'''







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

      '''simple docstring'''





      SCREAMING_SNAKE_CASE				:    Optional[Any]				       =					RePaintPipeline
      SCREAMING_SNAKE_CASE				:    Union[str, Any]				       =					IMAGE_INPAINTING_PARAMS - {"width", "height", "guidance_scale"}
      SCREAMING_SNAKE_CASE				:    Tuple				       =					PipelineTesterMixin.required_optional_params - {
          "latents",
          "num_images_per_prompt",
          "callback",
          "callback_steps",
      }
      SCREAMING_SNAKE_CASE				:    List[str]				       =					IMAGE_INPAINTING_BATCH_PARAMS
      SCREAMING_SNAKE_CASE				:    Any				       =					False




      def 							lowerCamelCase     (					self						):
             torch.manual_seed(0						)
             torch.manual_seed(0						)
             UpperCAmelCase__	:   Tuple												=	UNetaDModel(
                 block_out_channels=(32, 64)  ,		layers_per_block=2  ,		sample_size=32  ,		in_channels=3  ,		out_channels=3  ,		down_block_types=('''DownBlock2D''', '''AttnDownBlock2D''')  ,		up_block_types=('''AttnUpBlock2D''', '''UpBlock2D''')  ,		)
             UpperCAmelCase__	:   Optional[int]												=	RePaintScheduler()
             UpperCAmelCase__	:   Any												=	{'''unet''': unet, '''scheduler''': scheduler}
             return components




      def 							lowerCamelCase     (					self  ,		_UpperCAmelCase  ,		_UpperCAmelCase=0						):
             if str(_UpperCAmelCase						).startswith('''mps'''						):
                    UpperCAmelCase__	:   str												=	torch.manual_seed(_UpperCAmelCase						)
             else:
                    UpperCAmelCase__	:   Optional[int]												=	torch.Generator(device=_UpperCAmelCase						).manual_seed(_UpperCAmelCase						)
             UpperCAmelCase__	:   List[str]												=	np.random.RandomState(_UpperCAmelCase						).standard_normal((1, 3, 32, 32)						)
             UpperCAmelCase__	:   int												=	torch.from_numpy(_UpperCAmelCase						).to(device=_UpperCAmelCase  ,		dtype=torch.floataa						)
             UpperCAmelCase__	:   Dict												=	(image > 0).to(device=_UpperCAmelCase  ,		dtype=torch.floataa						)
             UpperCAmelCase__	:   List[Any]												=	{
                 '''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 							lowerCamelCase     (					self						):
             UpperCAmelCase__	:   Optional[int]												=	'''cpu'''  # ensure determinism for the device-dependent torch.Generator
             UpperCAmelCase__	:   Optional[Any]												=	self.get_dummy_components()
             UpperCAmelCase__	:   Union[str, Any]												=	RePaintPipeline(**_UpperCAmelCase						)
             UpperCAmelCase__	:   Tuple												=	sd_pipe.to(_UpperCAmelCase						)
             sd_pipe.set_progress_bar_config(disable=_UpperCAmelCase						)

             UpperCAmelCase__	:   List[str]												=	self.get_dummy_inputs(_UpperCAmelCase						)
             UpperCAmelCase__	:   int												=	sd_pipe(**_UpperCAmelCase						).images
             UpperCAmelCase__	:   Union[str, Any]												=	image[0, -3:, -3:, -1]

             assert image.shape == (1, 32, 32, 3)
             UpperCAmelCase__	:   int												=	np.array([1.00_00, 0.54_26, 0.54_97, 0.22_00, 1.00_00, 1.00_00, 0.56_23, 1.00_00, 0.62_74]						)

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




      @skip_mps
      def 							lowerCamelCase     (					self						):
             return super().test_save_load_local()




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




      @skip_mps
      def 							lowerCamelCase     (					self						):
             return super().test_dict_tuple_outputs_equivalent()




      @skip_mps
      def 							lowerCamelCase     (					self						):
             return super().test_save_load_optional_components()




      @skip_mps
      def 							lowerCamelCase     (					self						):
             return super().test_attention_slicing_forward_pass()




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

      '''simple docstring'''





      def 							lowerCamelCase     (					self						):
             super().tearDown()
             gc.collect()
             torch.cuda.empty_cache()




      def 							lowerCamelCase     (					self						):
             UpperCAmelCase__	:   str												=	load_image(
                 '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/'''
                 '''repaint/celeba_hq_256.png'''						)
             UpperCAmelCase__	:   List[str]												=	load_image(
                 '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/repaint/mask_256.png'''						)
             UpperCAmelCase__	:   Optional[int]												=	load_numpy(
                 '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/'''
                 '''repaint/celeba_hq_256_result.npy'''						)

             UpperCAmelCase__	:   List[str]												=	'''google/ddpm-ema-celebahq-256'''
             UpperCAmelCase__	:   str												=	UNetaDModel.from_pretrained(_UpperCAmelCase						)
             UpperCAmelCase__	:   Any												=	RePaintScheduler.from_pretrained(_UpperCAmelCase						)

             UpperCAmelCase__	:   Union[str, Any]												=	RePaintPipeline(unet=_UpperCAmelCase  ,		scheduler=_UpperCAmelCase						).to(_UpperCAmelCase						)
             repaint.set_progress_bar_config(disable=_UpperCAmelCase						)
             repaint.enable_attention_slicing()

             UpperCAmelCase__	:   List[Any]												=	torch.manual_seed(0						)
             UpperCAmelCase__	:   List[str]												=	repaint(
                 _UpperCAmelCase  ,		_UpperCAmelCase  ,		num_inference_steps=250  ,		eta=0.0  ,		jump_length=10  ,		jump_n_sample=10  ,		generator=_UpperCAmelCase  ,		output_type='''np'''  ,		)
             UpperCAmelCase__	:   Dict												=	output.images[0]

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







'''simple docstring'''







import re






def  lowerCAmelCase__		(					a_  :     Optional[int]			)   -> Optional[Any]:
       def docstring_decorator(a_  :     Dict			):
              UpperCAmelCase__	:   Optional[int]												=	fn.__doc__
              UpperCAmelCase__	:   Dict												=	func_doc.split('''\n'''			)
              UpperCAmelCase__	:   Any												=	0
              while i < len(a_			) and re.search(r'''^\s*Examples?:\s*$'''			,						lines[i]			) is None:
                     i += 1
              if i < len(a_			):
                     UpperCAmelCase__	:   List[Any]												=	example_docstring
                     UpperCAmelCase__	:   int												=	'''\n'''.join(a_			)
              else:
                     raise ValueError(
                         f"""The function {fn} should have an empty 'Examples:' in its docstring as placeholder, """
                         f"""current docstring is:\n{func_doc}"""			)
              UpperCAmelCase__	:   Any												=	func_doc
              return fn

       return docstring_decorator