




'''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 				_snake_case	(			A__		,		unittest.TestCase							):
   lowerCAmelCase_  :   Tuple		 =					RePaintPipeline
   lowerCAmelCase_  :   Union[str, Any]		 =					IMAGE_INPAINTING_PARAMS - {"width", "height", "guidance_scale"}
   lowerCAmelCase_  :   Union[str, Any]		 =					PipelineTesterMixin.required_optional_params - {
       "latents",
       "num_images_per_prompt",
       "callback",
       "callback_steps",
   }
   lowerCAmelCase_  :   List[Any]		 =					IMAGE_INPAINTING_BATCH_PARAMS
   lowerCAmelCase_  :   List[str]		 =					False




   def      lowerCAmelCase__       (      self							)       ->       Any:

          '''simple docstring'''




          torch.manual_seed(0							)
          torch.manual_seed(0							)
          snake_case_			      =   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")       ,							)
          snake_case_			      =   RePaintScheduler()
          snake_case_			      =   {"unet": unet, "scheduler": scheduler}
          return components




   def      lowerCAmelCase__       (      self       ,							a__       ,							a__=0							)       ->       List[str]:

          '''simple docstring'''




          if str(_lowerCAmelCase							).startswith("mps"							):
                 snake_case_			      =   torch.manual_seed(_lowerCAmelCase							)
          else:
                 snake_case_			      =   torch.Generator(device=_lowerCAmelCase							).manual_seed(_lowerCAmelCase							)
          snake_case_			      =   np.random.RandomState(_lowerCAmelCase							).standard_normal((1, 3, 32, 32)							)
          snake_case_			      =   torch.from_numpy(_lowerCAmelCase							).to(device=_lowerCAmelCase       ,							dtype=torch.floataa							)
          snake_case_			      =   (image > 0).to(device=_lowerCAmelCase       ,							dtype=torch.floataa							)
          snake_case_			      =   {
              "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							)       ->       List[Any]:

          '''simple docstring'''




          snake_case_			      =   "cpu"  # ensure determinism for the device-dependent torch.Generator
          snake_case_			      =   self.get_dummy_components()
          snake_case_			      =   RePaintPipeline(**_lowerCAmelCase							)
          snake_case_			      =   sd_pipe.to(_lowerCAmelCase							)
          sd_pipe.set_progress_bar_config(disable=_lowerCAmelCase							)

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

          assert image.shape == (1, 32, 32, 3)
          snake_case_			      =   np.array([1.0_0_0_0, 0.5_4_2_6, 0.5_4_9_7, 0.2_2_0_0, 1.0_0_0_0, 1.0_0_0_0, 0.5_6_2_3, 1.0_0_0_0, 0.6_2_7_4]							)

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




   @skip_mps
   def      lowerCAmelCase__       (      self							)       ->       Dict:

          '''simple docstring'''




          return super().test_save_load_local()




   @unittest.skip("non-deterministic pipeline"							)
   def      lowerCAmelCase__       (      self							)       ->       Tuple:

          '''simple docstring'''




          return super().test_inference_batch_single_identical()




   @skip_mps
   def      lowerCAmelCase__       (      self							)       ->       List[str]:

          '''simple docstring'''




          return super().test_dict_tuple_outputs_equivalent()




   @skip_mps
   def      lowerCAmelCase__       (      self							)       ->       int:

          '''simple docstring'''




          return super().test_save_load_optional_components()




   @skip_mps
   def      lowerCAmelCase__       (      self							)       ->       Optional[int]:

          '''simple docstring'''




          return super().test_attention_slicing_forward_pass()




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




   def      lowerCAmelCase__       (      self							)       ->       List[Any]:

          '''simple docstring'''




          super().tearDown()
          gc.collect()
          torch.cuda.empty_cache()




   def      lowerCAmelCase__       (      self							)       ->       Dict:

          '''simple docstring'''




          snake_case_			      =   load_image(
              "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/"
              "repaint/celeba_hq_256.png"							)
          snake_case_			      =   load_image(
              "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/repaint/mask_256.png"							)
          snake_case_			      =   load_numpy(
              "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/"
              "repaint/celeba_hq_256_result.npy"							)

          snake_case_			      =   "google/ddpm-ema-celebahq-256"
          snake_case_			      =   UNetaDModel.from_pretrained(_lowerCAmelCase							)
          snake_case_			      =   RePaintScheduler.from_pretrained(_lowerCAmelCase							)

          snake_case_			      =   RePaintPipeline(unet=_lowerCAmelCase       ,							scheduler=_lowerCAmelCase							).to(_lowerCAmelCase							)
          repaint.set_progress_bar_config(disable=_lowerCAmelCase							)
          repaint.enable_attention_slicing()

          snake_case_			      =   torch.manual_seed(0							)
          snake_case_			      =   repaint(
              _lowerCAmelCase       ,							_lowerCAmelCase       ,							num_inference_steps=250       ,							eta=0.0       ,							jump_length=10       ,							jump_n_sample=10       ,							generator=_lowerCAmelCase       ,							output_type="np"       ,							)
          snake_case_			      =   output.images[0]

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










'''simple docstring'''





import unittest
from pathlib import Path
from tempfile import TemporaryDirectory
from unittest.mock import Mock, patch

import diffusers.utils.hub_utils




class 				_snake_case	(			unittest.TestCase							):




			@patch("diffusers.utils.hub_utils.get_full_repo_name"							)
			def      lowerCAmelCase__       (      self       ,							a__							)       ->       None:

										'''simple docstring'''




										snake_case_			      =   "full_repo_name"
										with TemporaryDirectory() as tmpdir:
																	# Dummy args values
																	snake_case_			      =   Mock()
																	snake_case_			      =   tmpdir
																	snake_case_			      =   0
																	snake_case_			      =   "hub_token"
																	snake_case_			      =   "dataset_name"
																	snake_case_			      =   0.0_1
																	snake_case_			      =   100_000
																	snake_case_			      =   10_000
																	snake_case_			      =   0.0_1
																	snake_case_			      =   0.0_2
																	snake_case_			      =   0.0_3
																	snake_case_			      =   0.0_0_0_5
																	snake_case_			      =   0.0_0_0_0_0_1
																	snake_case_			      =   1
																	snake_case_			      =   10
																	snake_case_			      =   0.0_0_1
																	snake_case_			      =   0.1
																	snake_case_			      =   0.2
																	snake_case_			      =   True

																	# Model card mush be rendered and saved
																	diffusers.utils.hub_utils.create_model_card(a__       ,							model_name="model_name"							)
																	self.assertTrue((Path(a__							) / "README.md").is_file()							)




