





"""simple docstring"""


import gc
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    EulerAncestralDiscreteScheduler,
    PNDMScheduler,
    StableDiffusionModelEditingPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu, skip_mps

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineKarrasSchedulerTesterMixin, PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()



@skip_mps
class      lowercase_				(     __SCREAMING_SNAKE_CASE				,__SCREAMING_SNAKE_CASE				,__SCREAMING_SNAKE_CASE				,unittest.TestCase							):
       snake_case__				:							str											=     StableDiffusionModelEditingPipeline
       snake_case__				:							Dict											=     TEXT_TO_IMAGE_PARAMS
       snake_case__				:							Union[str, Any]											=     TEXT_TO_IMAGE_BATCH_PARAMS
       snake_case__				:							List[Any]											=     TEXT_TO_IMAGE_IMAGE_PARAMS
       snake_case__				:							Union[str, Any]											=     TEXT_TO_IMAGE_IMAGE_PARAMS

       def 		_SCREAMING_SNAKE_CASE(			self     ):






        '''simple docstring'''

        torch.manual_seed(0     )
        snake_case__    							=				UNetaDConditionModel(
            block_out_channels=(32, 64)   ,					layers_per_block=2   ,					sample_size=32   ,					in_channels=4   ,					out_channels=4   ,					down_block_types=("DownBlock2D", "CrossAttnDownBlock2D")   ,					up_block_types=("CrossAttnUpBlock2D", "UpBlock2D")   ,					cross_attention_dim=32   ,					)
        snake_case__    							=				DDIMScheduler()
        torch.manual_seed(0     )
        snake_case__    							=				AutoencoderKL(
            block_out_channels=[32, 64]   ,					in_channels=3   ,					out_channels=3   ,					down_block_types=["DownEncoderBlock2D", "DownEncoderBlock2D"]   ,					up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D"]   ,					latent_channels=4   ,					)
        torch.manual_seed(0     )
        snake_case__    							=				CLIPTextConfig(
            bos_token_id=0   ,					eos_token_id=2   ,					hidden_size=32   ,					intermediate_size=37   ,					layer_norm_eps=1e-05   ,					num_attention_heads=4   ,					num_hidden_layers=5   ,					pad_token_id=1   ,					vocab_size=1000   ,					)
        snake_case__    							=				CLIPTextModel(UpperCamelCase__     )
        snake_case__    							=				CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"     )

        snake_case__    							=				{
            '''unet''': unet,
            '''scheduler''': scheduler,
            '''vae''': vae,
            '''text_encoder''': text_encoder,
            '''tokenizer''': tokenizer,
            '''safety_checker''': None,
            '''feature_extractor''': None,
        }
        return components

       def 		_SCREAMING_SNAKE_CASE(			self   ,					__SCREAMING_SNAKE_CASE   ,					__SCREAMING_SNAKE_CASE=0     ):






        '''simple docstring'''

        snake_case__    							=				torch.manual_seed(UpperCamelCase__     )
        snake_case__    							=				{
            '''prompt''': '''A field of roses''',
            '''generator''': generator,
            # Setting height and width to None to prevent OOMs on CPU.
            '''height''': None,
            '''width''': None,
            '''num_inference_steps''': 2,
            '''guidance_scale''': 6.0,
            '''output_type''': '''numpy''',
        }
        return inputs

       def 		_SCREAMING_SNAKE_CASE(			self     ):






        '''simple docstring'''

        snake_case__    							=				'''cpu'''  # ensure determinism for the device-dependent torch.Generator
        snake_case__    							=				self.get_dummy_components()
        snake_case__    							=				StableDiffusionModelEditingPipeline(**UpperCamelCase__     )
        snake_case__    							=				sd_pipe.to(UpperCamelCase__     )
        sd_pipe.set_progress_bar_config(disable=UpperCamelCase__     )

        snake_case__    							=				self.get_dummy_inputs(UpperCamelCase__     )
        snake_case__    							=				sd_pipe(**UpperCamelCase__     ).images
        snake_case__    							=				image[0, -3:, -3:, -1]
        assert image.shape == (1, 64, 64, 3)

        snake_case__    							=				np.array([0.4755, 0.5132, 0.4976, 0.3904, 0.3554, 0.4765, 0.5139, 0.5158, 0.4889]     )

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

       def 		_SCREAMING_SNAKE_CASE(			self     ):






        '''simple docstring'''

        snake_case__    							=				'''cpu'''  # ensure determinism for the device-dependent torch.Generator
        snake_case__    							=				self.get_dummy_components()
        snake_case__    							=				StableDiffusionModelEditingPipeline(**UpperCamelCase__     )
        snake_case__    							=				sd_pipe.to(UpperCamelCase__     )
        sd_pipe.set_progress_bar_config(disable=UpperCamelCase__     )

        snake_case__    							=				self.get_dummy_inputs(UpperCamelCase__     )
        snake_case__    							=				'''french fries'''
        snake_case__    							=				sd_pipe(**UpperCamelCase__   ,					negative_prompt=UpperCamelCase__     )
        snake_case__    							=				output.images
        snake_case__    							=				image[0, -3:, -3:, -1]

        assert image.shape == (1, 64, 64, 3)

        snake_case__    							=				np.array([0.4992, 0.5101, 0.5004, 0.3949, 0.3604, 0.4735, 0.5216, 0.5204, 0.4913]     )

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

       def 		_SCREAMING_SNAKE_CASE(			self     ):






        '''simple docstring'''

        snake_case__    							=				'''cpu'''  # ensure determinism for the device-dependent torch.Generator
        snake_case__    							=				self.get_dummy_components()
        snake_case__    							=				EulerAncestralDiscreteScheduler(
            beta_start=0.00085   ,					beta_end=0.012   ,					beta_schedule="scaled_linear"     )
        snake_case__    							=				StableDiffusionModelEditingPipeline(**UpperCamelCase__     )
        snake_case__    							=				sd_pipe.to(UpperCamelCase__     )
        sd_pipe.set_progress_bar_config(disable=UpperCamelCase__     )

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

        assert image.shape == (1, 64, 64, 3)

        snake_case__    							=				np.array([0.4747, 0.5372, 0.4779, 0.4982, 0.5543, 0.4816, 0.5238, 0.4904, 0.5027]     )

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

       def 		_SCREAMING_SNAKE_CASE(			self     ):






        '''simple docstring'''

        snake_case__    							=				'''cpu'''  # ensure determinism for the device-dependent torch.Generator
        snake_case__    							=				self.get_dummy_components()
        snake_case__    							=				PNDMScheduler()
        snake_case__    							=				StableDiffusionModelEditingPipeline(**UpperCamelCase__     )
        snake_case__    							=				sd_pipe.to(UpperCamelCase__     )
        sd_pipe.set_progress_bar_config(disable=UpperCamelCase__     )

        snake_case__    							=				self.get_dummy_inputs(UpperCamelCase__     )
        # the pipeline does not expect pndm so test if it raises error.
        with self.assertRaises(UpperCamelCase__     ):
         snake_case__    							=				sd_pipe(**UpperCamelCase__     ).images

       def 		_SCREAMING_SNAKE_CASE(			self     ):






        '''simple docstring'''

        super().test_inference_batch_single_identical(expected_max_diff=5e-3     )

       def 		_SCREAMING_SNAKE_CASE(			self     ):






        '''simple docstring'''

        super().test_attention_slicing_forward_pass(expected_max_diff=5e-3     )



@slow
@require_torch_gpu
class      lowercase_				(     unittest.TestCase							):

       def 		_SCREAMING_SNAKE_CASE(			self     ):






        '''simple docstring'''

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

       def 		_SCREAMING_SNAKE_CASE(			self   ,					__SCREAMING_SNAKE_CASE=0     ):






        '''simple docstring'''

        snake_case__    							=				torch.manual_seed(UpperCamelCase__     )
        snake_case__    							=				{
            '''prompt''': '''A field of roses''',
            '''generator''': generator,
            '''num_inference_steps''': 3,
            '''guidance_scale''': 7.5,
            '''output_type''': '''numpy''',
        }
        return inputs

       def 		_SCREAMING_SNAKE_CASE(			self     ):






        '''simple docstring'''

        snake_case__    							=				'''CompVis/stable-diffusion-v1-4'''
        snake_case__    							=				StableDiffusionModelEditingPipeline.from_pretrained(UpperCamelCase__   ,					safety_checker=UpperCamelCase__     )
        pipe.to(UpperCamelCase__     )
        pipe.set_progress_bar_config(disable=UpperCamelCase__     )
        pipe.enable_attention_slicing()

        snake_case__    							=				self.get_inputs()
        snake_case__    							=				pipe(**UpperCamelCase__     ).images
        snake_case__    							=				image[0, -3:, -3:, -1].flatten()

        assert image.shape == (1, 512, 512, 3)

        snake_case__    							=				np.array(
            [0.6749496, 0.6386453, 0.51443267, 0.66094905, 0.61921215, 0.5491332, 0.5744417, 0.58075106, 0.5174658]     )

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

        # make sure image changes after editing
        pipe.edit_model("A pack of roses"   ,					"A pack of blue roses"     )

        snake_case__    							=				pipe(**UpperCamelCase__     ).images
        snake_case__    							=				image[0, -3:, -3:, -1].flatten()

        assert image.shape == (1, 512, 512, 3)

        assert np.abs(expected_slice - image_slice     ).max() > 1e-1

       def 		_SCREAMING_SNAKE_CASE(			self     ):






        '''simple docstring'''

        torch.cuda.empty_cache()
        torch.cuda.reset_max_memory_allocated()
        torch.cuda.reset_peak_memory_stats()

        snake_case__    							=				'''CompVis/stable-diffusion-v1-4'''
        snake_case__    							=				DDIMScheduler.from_pretrained(UpperCamelCase__   ,					subfolder="scheduler"     )
        snake_case__    							=				StableDiffusionModelEditingPipeline.from_pretrained(
            UpperCamelCase__   ,					scheduler=UpperCamelCase__   ,					safety_checker=UpperCamelCase__     )
        snake_case__    							=				pipe.to(UpperCamelCase__     )
        pipe.set_progress_bar_config(disable=UpperCamelCase__     )
        pipe.enable_attention_slicing(1     )
        pipe.enable_sequential_cpu_offload()

        snake_case__    							=				self.get_inputs()
        snake_case__    							=				pipe(**UpperCamelCase__     )

        snake_case__    							=				torch.cuda.max_memory_allocated()
        # make sure that less than 4.4 GB is allocated
        assert mem_bytes < 4.4 * 10**9








"""simple docstring"""


def 							a__			(  _UpperCAmelCase = 1_0_0_0	)    ->  int:

 '''simple docstring'''






 snake_case__    							=				[]
 snake_case__    							=				[]
 snake_case__    							=				3
 snake_case__    							=				5
 snake_case__    							=				1
 while True:
  snake_case__    							=				z * temp
  if result < n:
   zmulti.append(_UpperCAmelCase	)
   temp += 1
  else:
   snake_case__    							=				1
   break
 while True:
  snake_case__    							=				x * temp
  if result < n:
   xmulti.append(_UpperCAmelCase	)
   temp += 1
  else:
   break
 snake_case__    							=				list(set(xmulti + zmulti	)	)
 return sum(_UpperCAmelCase	)


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

