

'''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 		lowerCAmelCase__     (   a				,      unittest.TestCase      ):



 """simple docstring"""



 lowerCAmelCase__						      =   RePaintPipeline
 lowerCAmelCase__						      =   IMAGE_INPAINTING_PARAMS - {"width", "height", "guidance_scale"}
 lowerCAmelCase__						      =   PipelineTesterMixin.required_optional_params - {
     "latents",
     "num_images_per_prompt",
     "callback",
     "callback_steps",
 }
 lowerCAmelCase__						      =   IMAGE_INPAINTING_BATCH_PARAMS
 lowerCAmelCase__						      =   False
 def    UpperCAmelCase__	(	self      : List[str]    )						->				Tuple:


      """simple docstring"""




      torch.manual_seed(0    )
      torch.manual_seed(0    )
      __SCREAMING_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""")      ,							)
      __SCREAMING_SNAKE_CASE						     =   RePaintScheduler()
      __SCREAMING_SNAKE_CASE						     =   {"""unet""": unet, """scheduler""": scheduler}
      return components
 def    UpperCAmelCase__	(	self      : Optional[int]      ,							__SCREAMING_SNAKE_CASE      : Tuple      ,							__SCREAMING_SNAKE_CASE      : Any=0    )						->				Optional[Any]:


      """simple docstring"""




      if str(__SCREAMING_SNAKE_CASE    ).startswith("""mps"""    ):
           __SCREAMING_SNAKE_CASE						     =   torch.manual_seed(__SCREAMING_SNAKE_CASE    )
      else:
           __SCREAMING_SNAKE_CASE						     =   torch.Generator(device=__SCREAMING_SNAKE_CASE    ).manual_seed(__SCREAMING_SNAKE_CASE    )
      __SCREAMING_SNAKE_CASE						     =   np.random.RandomState(__SCREAMING_SNAKE_CASE    ).standard_normal((1, 3, 32, 32)    )
      __SCREAMING_SNAKE_CASE						     =   torch.from_numpy(__SCREAMING_SNAKE_CASE    ).to(device=__SCREAMING_SNAKE_CASE      ,							dtype=torch.floataa    )
      __SCREAMING_SNAKE_CASE						     =   (image > 0).to(device=__SCREAMING_SNAKE_CASE      ,							dtype=torch.floataa    )
      __SCREAMING_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    UpperCAmelCase__	(	self      : str    )						->				Tuple:


      """simple docstring"""




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

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

      assert image.shape == (1, 32, 32, 3)
      __SCREAMING_SNAKE_CASE						     =   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    UpperCAmelCase__	(	self      : Optional[int]    )						->				Union[str, Any]:


      """simple docstring"""




      return super().test_save_load_local()
 @unittest.skip("""non-deterministic pipeline"""    )
 def    UpperCAmelCase__	(	self      : List[Any]    )						->				int:


      """simple docstring"""




      return super().test_inference_batch_single_identical()
 @skip_mps
 def    UpperCAmelCase__	(	self      : Optional[Any]    )						->				Union[str, Any]:


      """simple docstring"""




      return super().test_dict_tuple_outputs_equivalent()
 @skip_mps
 def    UpperCAmelCase__	(	self      : List[Any]    )						->				Optional[int]:


      """simple docstring"""




      return super().test_save_load_optional_components()


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


      """simple docstring"""




      return super().test_attention_slicing_forward_pass()







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



 """simple docstring"""



 def    UpperCAmelCase__	(	self      : Any    )						->				Dict:


      """simple docstring"""




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


 def    UpperCAmelCase__	(	self      : str    )						->				Any:


      """simple docstring"""




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

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

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

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

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









'''simple docstring'''



from __future__ import annotations

from collections.abc import Callable







def      a__ (						a__   ,					a__   ,					a__   ,					a__ = 1_00   ,					):




     """simple docstring"""


     __SCREAMING_SNAKE_CASE						     =   x_start
     __SCREAMING_SNAKE_CASE						     =   fnc(a__		)
     __SCREAMING_SNAKE_CASE						     =   0.0

     for _ in range(a__		):
          # Approximates small segments of curve as linear and solve
          # for trapezoidal area
          __SCREAMING_SNAKE_CASE						     =   (x_end - x_start) / steps + xa
          __SCREAMING_SNAKE_CASE						     =   fnc(a__		)
          area += abs(fxa + fxa		) * (xa - xa) / 2

          # Increment step
          __SCREAMING_SNAKE_CASE						     =   xa
          __SCREAMING_SNAKE_CASE						     =   fxa
     return area


if __name__ == "__main__":







  def      a__ (						a__		):




       """simple docstring"""


       return x**3

  print('f(x) = x^3')
  print('The area between the curve, x = -10, x = 10 and the x axis is:')
  UpperCAmelCase				: Optional[Any]         =  1_0
  while i <= 1_0_0_0_0_0:
    UpperCAmelCase				: Union[str, Any]         =  trapezoidal_area(f, -5, 5, i)
    print(f"""with {i} steps: {area}""")
    i *= 1_0






