




'''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 	SCREAMING_SNAKE_CASE(    __A       ,				__A       ,				__A       ,				unittest.TestCase					):
       snake_case_			:					List[str]   = StableDiffusionModelEditingPipeline
       snake_case_			:					List[Any]   = TEXT_TO_IMAGE_PARAMS
       snake_case_			:					List[str]   = TEXT_TO_IMAGE_BATCH_PARAMS
       snake_case_			:					Dict   = TEXT_TO_IMAGE_IMAGE_PARAMS
       snake_case_			:					Any   = TEXT_TO_IMAGE_IMAGE_PARAMS

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

           """simple docstring"""



           torch.manual_seed(0					)
           __lowercase          =						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 ,		)
           __lowercase          =						DDIMScheduler()
           torch.manual_seed(0					)
           __lowercase          =						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					)
           __lowercase          =						CLIPTextConfig(
               bos_token_id=0 ,		eos_token_id=2 ,		hidden_size=32 ,		intermediate_size=37 ,		layer_norm_eps=1E-0_5 ,		num_attention_heads=4 ,		num_hidden_layers=5 ,		pad_token_id=1 ,		vocab_size=1000 ,		)
           __lowercase          =						CLIPTextModel(lowerCamelCase__					)
           __lowercase          =						CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""					)

           __lowercase          =						{
               """unet""": unet,
               """scheduler""": scheduler,
               """vae""": vae,
               """text_encoder""": text_encoder,
               """tokenizer""": tokenizer,
               """safety_checker""": None,
               """feature_extractor""": None,
           }
           return components

       def    snake_case__      (   self ,		lowerCamelCase__ ,		lowerCamelCase__=0					)   -> List[Any]:

           """simple docstring"""



           __lowercase          =						torch.manual_seed(lowerCamelCase__					)
           __lowercase          =						{
               """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    snake_case__      (   self					)   -> Dict:

           """simple docstring"""



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

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

           __lowercase          =						np.array([0.47_55, 0.51_32, 0.49_76, 0.39_04, 0.35_54, 0.47_65, 0.51_39, 0.51_58, 0.48_89]					)

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

       def    snake_case__      (   self					)   -> Tuple:

           """simple docstring"""



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

           __lowercase          =						self.get_dummy_inputs(lowerCamelCase__					)
           __lowercase          =						"""french fries"""
           __lowercase          =						sd_pipe(**lowerCamelCase__ ,		negative_prompt=lowerCamelCase__					)
           __lowercase          =						output.images
           __lowercase          =						image[0, -3:, -3:, -1]

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

           __lowercase          =						np.array([0.49_92, 0.51_01, 0.50_04, 0.39_49, 0.36_04, 0.47_35, 0.52_16, 0.52_04, 0.49_13]					)

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

       def    snake_case__      (   self					)   -> Tuple:

           """simple docstring"""



           __lowercase          =						"""cpu"""  # ensure determinism for the device-dependent torch.Generator
           __lowercase          =						self.get_dummy_components()
           __lowercase          =						EulerAncestralDiscreteScheduler(
               beta_start=0.0_00_85 ,		beta_end=0.0_12 ,		beta_schedule="""scaled_linear"""					)
           __lowercase          =						StableDiffusionModelEditingPipeline(**lowerCamelCase__					)
           __lowercase          =						sd_pipe.to(lowerCamelCase__					)
           sd_pipe.set_progress_bar_config(disable=lowerCamelCase__					)

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

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

           __lowercase          =						np.array([0.47_47, 0.53_72, 0.47_79, 0.49_82, 0.55_43, 0.48_16, 0.52_38, 0.49_04, 0.50_27]					)

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

       def    snake_case__      (   self					)   -> Optional[int]:

           """simple docstring"""



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

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

       def    snake_case__      (   self					)   -> Tuple:

           """simple docstring"""



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




       def    snake_case__      (   self					)   -> int:

           """simple docstring"""



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






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

       def    snake_case__      (   self					)   -> Tuple:

           """simple docstring"""



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

       def    snake_case__      (   self ,		lowerCamelCase__=0					)   -> Dict:

           """simple docstring"""



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

       def    snake_case__      (   self					)   -> int:

           """simple docstring"""



           __lowercase          =						"""CompVis/stable-diffusion-v1-4"""
           __lowercase          =						StableDiffusionModelEditingPipeline.from_pretrained(lowerCamelCase__ ,		safety_checker=lowerCamelCase__					)
           pipe.to(lowerCamelCase__					)
           pipe.set_progress_bar_config(disable=lowerCamelCase__					)
           pipe.enable_attention_slicing()

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

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

           __lowercase          =						np.array(
               [0.6_74_94_96, 0.6_38_64_53, 0.51_44_32_67, 0.66_09_49_05, 0.61_92_12_15, 0.5_49_13_32, 0.5_74_44_17, 0.58_07_51_06, 0.5_17_46_58]					)

           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"""					)

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

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

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




       def    snake_case__      (   self					)   -> Any:

           """simple docstring"""



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

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

           __lowercase          =						self.get_inputs()
           __lowercase          =						pipe(**lowerCamelCase__					)

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










'''simple docstring'''
A							:				int			     =	(1, 153, 370, 371, 1_634, 24_678_051, 115_132_219_018_763_992_565_095_597_973_971_522_401)
A							:				tuple			     =	(-153, -1, 0, 1.2, 200, "A", [], {}, None)
def     snake_case_  (       a__		:     int      ):



    """simple docstring"""




    if not isinstance(a__   ,a__      ) or n < 1:
        return False

    # Initialization of sum and number of digits.
    __lowercase          =						0
    __lowercase          =						0
    __lowercase          =						n
    # Calculation of digits of the number
    while temp > 0:
        number_of_digits += 1
        temp //= 10
    # Dividing number into separate digits and find Armstrong number
    __lowercase          =						n
    while temp > 0:
        __lowercase          =						temp % 10
        total += rem**number_of_digits
        temp //= 10
    return n == total
def     snake_case_  (       a__		:     int      ):



    """simple docstring"""




    if not isinstance(a__   ,a__      ) or n < 1:
        return False

    # Init a "histogram" of the digits
    __lowercase          =						[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
    __lowercase          =						0
    __lowercase          =						0
    __lowercase          =						n
    while temp > 0:
        __lowercase    ,__lowercase          =						divmod(a__   ,10      )
        digit_histogram[rem] += 1
        digit_total += 1

    for cnt, i in zip(a__   ,range(len(a__      )      )      ):
        total += cnt * i**digit_total

    return n == total
def     snake_case_  (       a__		:     int      ):



    """simple docstring"""




    if not isinstance(a__   ,a__      ) or n < 1:
        return False
    __lowercase          =						len(str(a__      )      )  # the power that all digits will be raised to
    # check if sum of each digit multiplied expo times is equal to number
    return n == sum(int(a__      ) ** expo for i in str(a__      )      )
def     snake_case_  (       ):



    """simple docstring"""




    __lowercase          =						int(input("""Enter an integer to see if it is an Armstrong number: """      ).strip()      )
    print(f'{num} is {"" if armstrong_number(a__      ) else "not "}an Armstrong number.'      )
    print(f'{num} is {"" if narcissistic_number(a__      ) else "not "}an Armstrong number.'      )
    print(f'{num} is {"" if pluperfect_number(a__      ) else "not "}an Armstrong number.'      )


if __name__ == "__main__":
  import doctest

  doctest.testmod()
  main()




