






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




   """simple docstring"""

   snake_case					       =		RePaintPipeline
   snake_case					       =		IMAGE_INPAINTING_PARAMS - {'''width''', '''height''', '''guidance_scale'''}
   snake_case					       =		PipelineTesterMixin.required_optional_params - {
       '''latents''',
       '''num_images_per_prompt''',
       '''callback''',
       '''callback_steps''',
   }
   snake_case					       =		IMAGE_INPAINTING_BATCH_PARAMS
   snake_case					       =		False

   def 		lowerCAmelCase				(	self				:			Union[str, Any]	):





         '''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 		lowerCAmelCase				(	self				:			int   ,   __UpperCAmelCase				:			List[Any]   ,   __UpperCAmelCase				:			str=0	):





         '''simple docstring'''





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





         '''simple docstring'''





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

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

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





         '''simple docstring'''





         return super().test_save_load_local()

   @unittest.skip("non-deterministic pipeline"	)
   def 		lowerCAmelCase				(	self				:			Optional[int]	):





         '''simple docstring'''





         return super().test_inference_batch_single_identical()

   @skip_mps
   def 		lowerCAmelCase				(	self				:			Dict	):





         '''simple docstring'''





         return super().test_dict_tuple_outputs_equivalent()

   @skip_mps
   def 		lowerCAmelCase				(	self				:			List[str]	):





         '''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      _UpperCAmelCase    (  unittest.TestCase		):




   """simple docstring"""

   def 		lowerCAmelCase				(	self				:			Dict	):





         '''simple docstring'''





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

   def 		lowerCAmelCase				(	self				:			int	):





         '''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(__UpperCAmelCase	)
         _A      =			RePaintScheduler.from_pretrained(__UpperCAmelCase	)

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

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

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













'''simple docstring'''




import math

def       __lowercase		(    __lowercase ) ->		bool:

      '''simple docstring'''


      if 1 < number < 4:
            # 2 and 3 are primes
            return True
      elif number < 2 or number % 2 == 0 or number % 3 == 0:
            # Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
            return False

      # All primes number are in format of 6k +/- 1
      for i in range(5     ,						int(math.sqrt(__lowercase ) + 1 )     ,						6 ):
            if number % i == 0 or number % (i + 2) == 0:
                  return False
      return True

def       __lowercase		(    __lowercase = 6008_5147_5143 ) ->		int:

      '''simple docstring'''


      try:
            _A      =			int(__lowercase )
      except (TypeError, ValueError):
            raise TypeError("Parameter n must be int or castable to int." )
      if n <= 0:
            raise ValueError("Parameter n must be greater than or equal to one." )
      _A      =			0
      if is_prime(__lowercase ):
            return n
      while n % 2 == 0:
            n //= 2
      if is_prime(__lowercase ):
            return n
      for i in range(3     ,						int(math.sqrt(__lowercase ) ) + 1     ,						2 ):
            if n % i == 0:
                  if is_prime(n // i ):
                        _A      =			n // i
                        break
                  elif is_prime(__lowercase ):
                        _A      =			i
      return max_number


if __name__ == "__main__":
    print(F"""{solution() = }""")





