





"""simple docstring"""



import gc
import random
import unittest

import numpy as np
import torch
from PIL import Image

from diffusers import (
    DDIMScheduler,
    KandinskyVaaControlnetImgaImgPipeline,
    KandinskyVaaPriorEmbaEmbPipeline,
    UNetaDConditionModel,
    VQModel,
)
from diffusers.utils import floats_tensor, load_image, 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 		__snake_case (		SCREAMING_SNAKE_CASE__							,							unittest.TestCase					):





 """simple docstring"""


 _lowerCamelCase				=					KandinskyVaaControlnetImgaImgPipeline
 _lowerCamelCase				=					["""image_embeds""", """negative_image_embeds""", """image""", """hint"""]
 _lowerCamelCase				=					["""image_embeds""", """negative_image_embeds""", """image""", """hint"""]
 _lowerCamelCase				=					[
     """generator""",
     """height""",
     """width""",
     """strength""",
     """guidance_scale""",
     """num_inference_steps""",
     """return_dict""",
     """guidance_scale""",
     """num_images_per_prompt""",
     """output_type""",
     """return_dict""",
 ]
 _lowerCamelCase				=					False

 @property
 def  UpperCamelCase__(   self  ):



     '''simple docstring'''




     return 32

 @property
 def  UpperCamelCase__(   self  ):



     '''simple docstring'''




     return 32

 @property
 def  UpperCamelCase__(   self  ):



     '''simple docstring'''




     return self.time_input_dim

 @property
 def  UpperCamelCase__(   self  ):



     '''simple docstring'''




     return self.time_input_dim * 4

 @property
 def  UpperCamelCase__(   self  ):



     '''simple docstring'''




     return 100

 @property
 def  UpperCamelCase__(   self  ):



     '''simple docstring'''




     torch.manual_seed(0  )

     __A   :						Any									=					{
         '''in_channels''': 8,
         # Out channels is double in channels because predicts mean and variance
         '''out_channels''': 8,
         '''addition_embed_type''': '''image_hint''',
         '''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''': '''image_proj''',
         '''cross_attention_dim''': self.cross_attention_dim,
         '''attention_head_dim''': 4,
         '''resnet_time_scale_shift''': '''scale_shift''',
         '''class_embed_type''': None,
     }

     __A   :						str									=					UNetaDConditionModel(**__lowerCamelCase  )
     return model

 @property
 def  UpperCamelCase__(   self  ):



     '''simple docstring'''




     return {
         "block_out_channels": [32, 32, 64, 64],
         "down_block_types": [
             "DownEncoderBlock2D",
             "DownEncoderBlock2D",
             "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", "UpDecoderBlock2D", "UpDecoderBlock2D"],
         "vq_embed_dim": 4,
     }

 @property
 def  UpperCamelCase__(   self  ):



     '''simple docstring'''




     torch.manual_seed(0  )
     __A   :						Tuple									=					VQModel(**self.dummy_movq_kwargs  )
     return model

 def  UpperCamelCase__(   self  ):



     '''simple docstring'''




     __A   :						Union[str, Any]									=					self.dummy_unet
     __A   :						Optional[int]									=					self.dummy_movq

     __A   :						Optional[Any]									=					{
         '''num_train_timesteps''': 1000,
         '''beta_schedule''': '''linear''',
         '''beta_start''': 0.0_0_0_8_5,
         '''beta_end''': 0.0_1_2,
         '''clip_sample''': False,
         '''set_alpha_to_one''': False,
         '''steps_offset''': 0,
         '''prediction_type''': '''epsilon''',
         '''thresholding''': False,
     }

     __A   :						Tuple									=					DDIMScheduler(**__lowerCamelCase  )

     __A   :						Union[str, Any]									=					{
         '''unet''': unet,
         '''scheduler''': scheduler,
         '''movq''': movq,
     }

     return components

 def  UpperCamelCase__(   self ,						__lowerCamelCase ,						__lowerCamelCase=0  ):



     '''simple docstring'''




     __A   :						Tuple									=					floats_tensor((1, self.text_embedder_hidden_size) ,						rng=random.Random(__lowerCamelCase  )  ).to(__lowerCamelCase  )
     __A   :						Dict									=					floats_tensor((1, self.text_embedder_hidden_size) ,						rng=random.Random(seed + 1  )  ).to(
         __lowerCamelCase  )
     # create init_image
     __A   :						Tuple									=					floats_tensor((1, 3, 64, 64) ,						rng=random.Random(__lowerCamelCase  )  ).to(__lowerCamelCase  )
     __A   :						List[Any]									=					image.cpu().permute(0 ,						2 ,						3 ,						1  )[0]
     __A   :						int									=					Image.fromarray(np.uinta(__lowerCamelCase  )  ).convert('''RGB'''  ).resize((256, 256)  )
     # create hint
     __A   :						Optional[int]									=					floats_tensor((1, 3, 64, 64) ,						rng=random.Random(__lowerCamelCase  )  ).to(__lowerCamelCase  )

     if str(__lowerCamelCase  ).startswith('''mps'''  ):
         __A   :						Optional[int]									=					torch.manual_seed(__lowerCamelCase  )
     else:
         __A   :						str									=					torch.Generator(device=__lowerCamelCase  ).manual_seed(__lowerCamelCase  )
     __A   :						int									=					{
         '''image''': init_image,
         '''image_embeds''': image_embeds,
         '''negative_image_embeds''': negative_image_embeds,
         '''hint''': hint,
         '''generator''': generator,
         '''height''': 64,
         '''width''': 64,
         '''num_inference_steps''': 10,
         '''guidance_scale''': 7.0,
         '''strength''': 0.2,
         '''output_type''': '''np''',
     }
     return inputs







 def  UpperCamelCase__(   self  ):



     '''simple docstring'''




     __A   :						Optional[Any]									=					'''cpu'''

     __A   :						Optional[Any]									=					self.get_dummy_components()

     __A   :						List[str]									=					self.pipeline_class(**__lowerCamelCase  )
     __A   :						str									=					pipe.to(__lowerCamelCase  )

     pipe.set_progress_bar_config(disable=__lowerCamelCase  )

     __A   :						List[str]									=					pipe(**self.get_dummy_inputs(__lowerCamelCase  )  )
     __A   :						Optional[int]									=					output.images

     __A   :						str									=					pipe(
         **self.get_dummy_inputs(__lowerCamelCase  ) ,						return_dict=__lowerCamelCase ,						)[0]

     __A   :						str									=					image[0, -3:, -3:, -1]
     __A   :						Optional[Any]									=					image_from_tuple[0, -3:, -3:, -1]

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

     __A   :						Tuple									=					np.array(
         [0.5_4_9_8_5_0_3_4, 0.5_5_5_0_9_3_6_5, 0.5_2_5_6_1_5_0_4, 0.5_5_7_0_4_9_4, 0.5_5_9_3_8_1_8, 0.5_2_6_3_9_7_9, 0.5_0_2_8_5_6_4_3, 0.5_0_6_9_8_4_6, 0.5_1_1_9_6_7_3_6]  )
     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 		__snake_case (		unittest.TestCase					):





 """simple docstring"""


 def  UpperCamelCase__(   self  ):



     '''simple docstring'''




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







 def  UpperCamelCase__(   self  ):



     '''simple docstring'''




     __A   :						Optional[int]									=					load_numpy(
         '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
         '''/kandinskyv22/kandinskyv22_controlnet_img2img_robotcat_fp16.npy'''  )

     __A   :						Union[str, Any]									=					load_image(
         '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main''' '''/kandinsky/cat.png'''  )
     __A   :						int									=					init_image.resize((512, 512)  )

     __A   :						List[Any]									=					load_image(
         '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
         '''/kandinskyv22/hint_image_cat.png'''  )
     __A   :						Optional[int]									=					torch.from_numpy(np.array(__lowerCamelCase  )  ).float() / 255.0
     __A   :						Optional[Any]									=					hint.permute(2 ,						0 ,						1  ).unsqueeze(0  )

     __A   :						Optional[int]									=					'''A robot, 4k photo'''

     __A   :						Optional[Any]									=					KandinskyVaaPriorEmbaEmbPipeline.from_pretrained(
         '''kandinsky-community/kandinsky-2-2-prior''' ,						torch_dtype=torch.floataa  )
     pipe_prior.to(__lowerCamelCase  )

     __A   :						Dict									=					KandinskyVaaControlnetImgaImgPipeline.from_pretrained(
         '''kandinsky-community/kandinsky-2-2-controlnet-depth''' ,						torch_dtype=torch.floataa  )
     __A   :						Union[str, Any]									=					pipeline.to(__lowerCamelCase  )

     pipeline.set_progress_bar_config(disable=__lowerCamelCase  )

     __A   :						Any									=					torch.Generator(device='''cpu'''  ).manual_seed(0  )

     __A   :						Optional[Any]									=					pipe_prior(
         __lowerCamelCase ,						image=__lowerCamelCase ,						strength=0.8_5 ,						generator=__lowerCamelCase ,						negative_prompt='''''' ,						).to_tuple()

     __A   :						str									=					pipeline(
         image=__lowerCamelCase ,						image_embeds=__lowerCamelCase ,						negative_image_embeds=__lowerCamelCase ,						hint=__lowerCamelCase ,						generator=__lowerCamelCase ,						num_inference_steps=100 ,						height=512 ,						width=512 ,						strength=0.5 ,						output_type='''np''' ,						)

     __A   :						Optional[Any]									=					output.images[0]

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

     assert_mean_pixel_difference(__lowerCamelCase ,						__lowerCamelCase  )











"""simple docstring"""



def 		__lowercase					(       )       ->Tuple:



    '''simple docstring'''







    __A   :						str									=					[]
    __A   :						List[Any]									=					1

    while len(snake_case_						) < 1e6:
        constant.append(str(snake_case_						)						)
        i += 1

    __A   :						Any									=					''''''.join(snake_case_						)

    return (
        int(constant[0]						)
        * int(constant[9]						)
        * int(constant[99]						)
        * int(constant[999]						)
        * int(constant[9999]						)
        * int(constant[99999]						)
        * int(constant[999999]						)
    )


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




