


"""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   (	_UpperCamelCase  ,					unittest.TestCase):
		__UpperCamelCase							     =      RePaintPipeline
		__UpperCamelCase							     =      IMAGE_INPAINTING_PARAMS - {'width', 'height', 'guidance_scale'}
		__UpperCamelCase							     =      PipelineTesterMixin.required_optional_params - {
		    'latents',
		    'num_images_per_prompt',
		    'callback',
		    'callback_steps',
		}
		__UpperCamelCase							     =      IMAGE_INPAINTING_BATCH_PARAMS
		__UpperCamelCase							     =      False







		def 			a_			(       self   :							Union[str, Any]		)							->    str:





						'''simple docstring'''







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







		def 			a_			(       self   :							str     , a__   :							Optional[Any]     , a__   :							List[str]=0		)							->    List[Any]:





						'''simple docstring'''







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





						'''simple docstring'''







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

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

						assert image.shape == (1, 32, 32, 3)
						_A       	=      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 			a_			(       self   :							List[str]		)							->    int:





						'''simple docstring'''







						return super().test_save_load_local()







		@unittest.skip("non-deterministic pipeline"		)
		def 			a_			(       self   :							int		)							->    int:





						'''simple docstring'''







						return super().test_inference_batch_single_identical()







		@skip_mps
		def 			a_			(       self   :							Optional[Any]		)							->    List[str]:





						'''simple docstring'''







						return super().test_dict_tuple_outputs_equivalent()







		@skip_mps
		def 			a_			(       self   :							Union[str, Any]		)							->    Any:





						'''simple docstring'''







						return super().test_save_load_optional_components()







		@skip_mps
		def 			a_			(       self   :							Optional[int]		)							->    List[Any]:





						'''simple docstring'''







						return super().test_attention_slicing_forward_pass()





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







		def 			a_			(       self   :							Tuple		)							->    Any:





						'''simple docstring'''







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







		def 			a_			(       self   :							Union[str, Any]		)							->    Union[str, Any]:





						'''simple docstring'''







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

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

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

						_A       	=      torch.manual_seed(0		)
						_A       	=      repaint(
						    a__     , a__     , num_inference_steps=2_50     , eta=0.0     , jump_length=10     , jump_n_sample=10     , generator=a__     , output_type="np"     , )
						_A       	=      output.images[0]

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



"""simple docstring"""


from math import factorial






def   a__			(					__lowercase  ,      __lowercase )						->						List[Any]:
				return factorial(__lowercase ) / (factorial(__lowercase ) * factorial(n - r ))






def   a__			(					)						->						List[str]:
				_A       	=      0

				for i in range(1  ,      101 ):
								for j in range(1  ,      i + 1 ):
												if combinations(__lowercase  ,      __lowercase ) > 1E6:
																total += 1
				return total


if __name__ == "__main__":
		print(solution())