




'''simple docstring'''
import gc
import random
import unittest

import numpy as np
import torch
from transformers import XLMRobertaTokenizerFast

from diffusers import DDIMScheduler, KandinskyPipeline, KandinskyPriorPipeline, UNetaDConditionModel, VQModel
from diffusers.pipelines.kandinsky.text_encoder import MCLIPConfig, MultilingualCLIP
from diffusers.utils import floats_tensor, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference


enable_full_determinism()






class 	SCREAMING_SNAKE_CASE(    __A       ,				unittest.TestCase					):
       snake_case_			:					Dict   = KandinskyPipeline
       snake_case_			:					Optional[Any]   = [
           """prompt""",
           """image_embeds""",
           """negative_image_embeds""",
       ]
       snake_case_			:					Dict   = ["""prompt""", """negative_prompt""", """image_embeds""", """negative_image_embeds"""]
       snake_case_			:					Optional[int]   = [
           """generator""",
           """height""",
           """width""",
           """latents""",
           """guidance_scale""",
           """negative_prompt""",
           """num_inference_steps""",
           """return_dict""",
           """guidance_scale""",
           """num_images_per_prompt""",
           """output_type""",
           """return_dict""",
       ]
       snake_case_			:					str   = False

       @property
       def    snake_case__      (   self					)   -> Union[str, Any]:

           """simple docstring"""



           return 32

       @property
       def    snake_case__      (   self					)   -> Optional[Any]:

           """simple docstring"""



           return 32

       @property
       def    snake_case__      (   self					)   -> Union[str, Any]:

           """simple docstring"""



           return self.time_input_dim

       @property
       def    snake_case__      (   self					)   -> Tuple:

           """simple docstring"""



           return self.time_input_dim * 4

       @property
       def    snake_case__      (   self					)   -> Optional[Any]:

           """simple docstring"""



           return 100

       @property
       def    snake_case__      (   self					)   -> int:

           """simple docstring"""



           __lowercase          =						XLMRobertaTokenizerFast.from_pretrained("""YiYiXu/tiny-random-mclip-base"""					)
           return tokenizer

       @property
       def    snake_case__      (   self					)   -> Union[str, Any]:

           """simple docstring"""



           torch.manual_seed(0					)
           __lowercase          =						MCLIPConfig(
               numDims=self.cross_attention_dim ,		transformerDimensions=self.text_embedder_hidden_size ,		hidden_size=self.text_embedder_hidden_size ,		intermediate_size=37 ,		num_attention_heads=4 ,		num_hidden_layers=5 ,		vocab_size=1005 ,		)

           __lowercase          =						MultilingualCLIP(lowerCamelCase__					)
           __lowercase          =						text_encoder.eval()

           return text_encoder

       @property
       def    snake_case__      (   self					)   -> Any:

           """simple docstring"""



           torch.manual_seed(0					)

           __lowercase          =						{
               """in_channels""": 4,
               # Out channels is double in channels because predicts mean and variance
               """out_channels""": 8,
               """addition_embed_type""": """text_image""",
               """down_block_types""": ("""ResnetDownsampleBlock2D""", """SimpleCrossAttnDownBlock2D"""),
               """up_block_types""": ("""SimpleCrossAttnUpBlock2D""", """ResnetUpsampleBlock2D"""),
               """mid_block_type""": """UNetMidBlock2DSimpleCrossAttn""",
               """block_out_channels""": (self.block_out_channels_a, self.block_out_channels_a * 2),
               """layers_per_block""": 1,
               """encoder_hid_dim""": self.text_embedder_hidden_size,
               """encoder_hid_dim_type""": """text_image_proj""",
               """cross_attention_dim""": self.cross_attention_dim,
               """attention_head_dim""": 4,
               """resnet_time_scale_shift""": """scale_shift""",
               """class_embed_type""": None,
           }

           __lowercase          =						UNetaDConditionModel(**lowerCamelCase__					)
           return model

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

           """simple docstring"""



           return {
               "block_out_channels": [32, 64],
               "down_block_types": ["DownEncoderBlock2D", "AttnDownEncoderBlock2D"],
               "in_channels": 3,
               "latent_channels": 4,
               "layers_per_block": 1,
               "norm_num_groups": 8,
               "norm_type": "spatial",
               "num_vq_embeddings": 12,
               "out_channels": 3,
               "up_block_types": [
                   "AttnUpDecoderBlock2D",
                   "UpDecoderBlock2D",
               ],
               "vq_embed_dim": 4,
           }

       @property
       def    snake_case__      (   self					)   -> List[str]:

           """simple docstring"""



           torch.manual_seed(0					)
           __lowercase          =						VQModel(**self.dummy_movq_kwargs					)
           return model

       def    snake_case__      (   self					)   -> Tuple:

           """simple docstring"""



           __lowercase          =						self.dummy_text_encoder
           __lowercase          =						self.dummy_tokenizer
           __lowercase          =						self.dummy_unet
           __lowercase          =						self.dummy_movq

           __lowercase          =						DDIMScheduler(
               num_train_timesteps=1000 ,		beta_schedule="""linear""" ,		beta_start=0.0_00_85 ,		beta_end=0.0_12 ,		clip_sample=lowerCamelCase__ ,		set_alpha_to_one=lowerCamelCase__ ,		steps_offset=1 ,		prediction_type="""epsilon""" ,		thresholding=lowerCamelCase__ ,		)

           __lowercase          =						{
               """text_encoder""": text_encoder,
               """tokenizer""": tokenizer,
               """unet""": unet,
               """scheduler""": scheduler,
               """movq""": movq,
           }
           return components

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

           """simple docstring"""



           __lowercase          =						floats_tensor((1, self.cross_attention_dim) ,		rng=random.Random(lowerCamelCase__					)					).to(lowerCamelCase__					)
           __lowercase          =						floats_tensor((1, self.cross_attention_dim) ,		rng=random.Random(seed + 1					)					).to(lowerCamelCase__					)
           if str(lowerCamelCase__					).startswith("""mps"""					):
               __lowercase          =						torch.manual_seed(lowerCamelCase__					)
           else:
               __lowercase          =						torch.Generator(device=lowerCamelCase__					).manual_seed(lowerCamelCase__					)
           __lowercase          =						{
               """prompt""": """horse""",
               """image_embeds""": image_embeds,
               """negative_image_embeds""": negative_image_embeds,
               """generator""": generator,
               """height""": 64,
               """width""": 64,
               """guidance_scale""": 4.0,
               """num_inference_steps""": 2,
               """output_type""": """np""",
           }
           return inputs




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

           """simple docstring"""



           __lowercase          =						"""cpu"""

           __lowercase          =						self.get_dummy_components()

           __lowercase          =						self.pipeline_class(**lowerCamelCase__					)
           __lowercase          =						pipe.to(lowerCamelCase__					)

           pipe.set_progress_bar_config(disable=lowerCamelCase__					)

           __lowercase          =						pipe(**self.get_dummy_inputs(lowerCamelCase__					)					)
           __lowercase          =						output.images

           __lowercase          =						pipe(
               **self.get_dummy_inputs(lowerCamelCase__					) ,		return_dict=lowerCamelCase__ ,		)[0]

           __lowercase          =						image[0, -3:, -3:, -1]
           __lowercase          =						image_from_tuple[0, -3:, -3:, -1]

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

           __lowercase          =						np.array(
               [0.32_86_63, 1.0, 0.23_21_68_73, 1.0, 0.92_71_75_64, 0.4_63_90_46, 0.96_89_47_77, 0.31_71_33_78, 0.6_29_39_53]					)

           assert (
               np.abs(image_slice.flatten() - expected_slice					).max() < 1E-2
           ), F' expected_slice {expected_slice}, but got {image_slice.flatten()}'
           assert (
               np.abs(image_from_tuple_slice.flatten() - expected_slice					).max() < 1E-2
           ), F' expected_slice {expected_slice}, but got {image_from_tuple_slice.flatten()}'






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

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

           """simple docstring"""



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




       def    snake_case__      (   self					)   -> Dict:

           """simple docstring"""



           __lowercase          =						load_numpy(
               """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
               """/kandinsky/kandinsky_text2img_cat_fp16.npy"""					)

           __lowercase          =						KandinskyPriorPipeline.from_pretrained(
               """kandinsky-community/kandinsky-2-1-prior""" ,		torch_dtype=torch.floataa					)
           pipe_prior.to(lowerCamelCase__					)

           __lowercase          =						KandinskyPipeline.from_pretrained("""kandinsky-community/kandinsky-2-1""" ,		torch_dtype=torch.floataa					)
           __lowercase          =						pipeline.to(lowerCamelCase__					)
           pipeline.set_progress_bar_config(disable=lowerCamelCase__					)

           __lowercase          =						"""red cat, 4k photo"""

           __lowercase          =						torch.Generator(device="""cuda"""					).manual_seed(0					)
           __lowercase    ,__lowercase          =						pipe_prior(
               lowerCamelCase__ ,		generator=lowerCamelCase__ ,		num_inference_steps=5 ,		negative_prompt="""""" ,		).to_tuple()

           __lowercase          =						torch.Generator(device="""cuda"""					).manual_seed(0					)
           __lowercase          =						pipeline(
               lowerCamelCase__ ,		image_embeds=lowerCamelCase__ ,		negative_image_embeds=lowerCamelCase__ ,		generator=lowerCamelCase__ ,		num_inference_steps=100 ,		output_type="""np""" ,		)

           __lowercase          =						output.images[0]

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

           assert_mean_pixel_difference(lowerCamelCase__ ,		lowerCamelCase__					)










'''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()




