





import random
import unittest

import numpy as np
import torch
from PIL import Image
from torch import nn
from transformers import (
    CLIPImageProcessor,
    CLIPTextConfig,
    CLIPTextModelWithProjection,
    CLIPTokenizer,
    CLIPVisionConfig,
    CLIPVisionModelWithProjection,
)

from diffusers import KandinskyVaaPriorEmbaEmbPipeline, PriorTransformer, UnCLIPScheduler
from diffusers.utils import floats_tensor, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, skip_mps

from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()




class 	_UpperCAmelCase						( _lowercase			,							unittest.TestCase       ):
					__A        = KandinskyVaaPriorEmbaEmbPipeline
					__A        = ["prompt", "image"]
					__A        = ["prompt", "image"]
					__A        = [
					    "num_images_per_prompt",
					    "strength",
					    "generator",
					    "num_inference_steps",
					    "latents",
					    "negative_prompt",
					    "guidance_scale",
					    "output_type",
					    "return_dict",
					]
					__A        = False




					@property
					def 						snake_case_		(    self							)    ->	List[Any]:
							return 32




					@property
					def 						snake_case_		(    self							)    ->	Union[str, Any]:
							return 32




					@property
					def 						snake_case_		(    self							)    ->	List[str]:
							return self.time_input_dim




					@property
					def 						snake_case_		(    self							)    ->	Optional[int]:
							return self.time_input_dim * 4




					@property
					def 						snake_case_		(    self							)    ->	List[str]:
							return 100




					@property
					def 						snake_case_		(    self							)    ->	Optional[int]:
							UpperCamelCase__								=						CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""							)
							return tokenizer




					@property
					def 						snake_case_		(    self							)    ->	Optional[Any]:
							torch.manual_seed(0							)
							UpperCamelCase__								=						CLIPTextConfig(
							    bos_token_id=0     ,   eos_token_id=2     ,   hidden_size=self.text_embedder_hidden_size     ,   projection_dim=self.text_embedder_hidden_size     ,   intermediate_size=37     ,   layer_norm_eps=1E-0_5     ,   num_attention_heads=4     ,   num_hidden_layers=5     ,   pad_token_id=1     ,   vocab_size=1_000     ,   )
							return CLIPTextModelWithProjection(__lowerCAmelCase							)




					@property
					def 						snake_case_		(    self							)    ->	Optional[Any]:
							torch.manual_seed(0							)

							UpperCamelCase__								=						{
							    """num_attention_heads""": 2,
							    """attention_head_dim""": 12,
							    """embedding_dim""": self.text_embedder_hidden_size,
							    """num_layers""": 1,
							}

							UpperCamelCase__								=						PriorTransformer(**__lowerCAmelCase							)
							# clip_std and clip_mean is initialized to be 0 so PriorTransformer.post_process_latents will always return 0 - set clip_std to be 1 so it won't return 0
							UpperCamelCase__								=						nn.Parameter(torch.ones(model.clip_std.shape							)							)
							return model




					@property
					def 						snake_case_		(    self							)    ->	Optional[Any]:
							torch.manual_seed(0							)
							UpperCamelCase__								=						CLIPVisionConfig(
							    hidden_size=self.text_embedder_hidden_size     ,   image_size=224     ,   projection_dim=self.text_embedder_hidden_size     ,   intermediate_size=37     ,   num_attention_heads=4     ,   num_channels=3     ,   num_hidden_layers=5     ,   patch_size=14     ,   )

							UpperCamelCase__								=						CLIPVisionModelWithProjection(__lowerCAmelCase							)
							return model




					@property
					def 						snake_case_		(    self							)    ->	Any:
							UpperCamelCase__								=						CLIPImageProcessor(
							    crop_size=224     ,   do_center_crop=__lowerCAmelCase     ,   do_normalize=__lowerCAmelCase     ,   do_resize=__lowerCAmelCase     ,   image_mean=[0.4_8_1_4_5_4_6_6, 0.4_5_7_8_2_7_5, 0.4_0_8_2_1_0_7_3]     ,   image_std=[0.2_6_8_6_2_9_5_4, 0.2_6_1_3_0_2_5_8, 0.2_7_5_7_7_7_1_1]     ,   resample=3     ,   size=224     ,   )

							return image_processor




					def 						snake_case_		(    self							)    ->	Optional[int]:
							UpperCamelCase__								=						self.dummy_prior
							UpperCamelCase__								=						self.dummy_image_encoder
							UpperCamelCase__								=						self.dummy_text_encoder
							UpperCamelCase__								=						self.dummy_tokenizer
							UpperCamelCase__								=						self.dummy_image_processor

							UpperCamelCase__								=						UnCLIPScheduler(
							    variance_type="""fixed_small_log"""     ,   prediction_type="""sample"""     ,   num_train_timesteps=1_000     ,   clip_sample=__lowerCAmelCase     ,   clip_sample_range=1_0.0     ,   )

							UpperCamelCase__								=						{
							    """prior""": prior,
							    """image_encoder""": image_encoder,
							    """text_encoder""": text_encoder,
							    """tokenizer""": tokenizer,
							    """scheduler""": scheduler,
							    """image_processor""": image_processor,
							}

							return components




					def 						snake_case_		(    self     ,   __lowerCAmelCase     ,   __lowerCAmelCase=0							)    ->	str:
							if str(__lowerCAmelCase							).startswith("""mps"""							):
									UpperCamelCase__								=						torch.manual_seed(__lowerCAmelCase							)
							else:
									UpperCamelCase__								=						torch.Generator(device=__lowerCAmelCase							).manual_seed(__lowerCAmelCase							)

							UpperCamelCase__								=						floats_tensor((1, 3, 64, 64)     ,   rng=random.Random(__lowerCAmelCase							)							).to(__lowerCAmelCase							)
							UpperCamelCase__								=						image.cpu().permute(0     ,   2     ,   3     ,   1							)[0]
							UpperCamelCase__								=						Image.fromarray(np.uinta(__lowerCAmelCase							)							).convert("""RGB"""							).resize((256, 256)							)

							UpperCamelCase__								=						{
							    """prompt""": """horse""",
							    """image""": init_image,
							    """strength""": 0.5,
							    """generator""": generator,
							    """guidance_scale""": 4.0,
							    """num_inference_steps""": 2,
							    """output_type""": """np""",
							}
							return inputs




					def 						snake_case_		(    self							)    ->	Union[str, Any]:
							UpperCamelCase__								=						"""cpu"""

							UpperCamelCase__								=						self.get_dummy_components()

							UpperCamelCase__								=						self.pipeline_class(**__lowerCAmelCase							)
							UpperCamelCase__								=						pipe.to(__lowerCAmelCase							)

							pipe.set_progress_bar_config(disable=__lowerCAmelCase							)

							UpperCamelCase__								=						pipe(**self.get_dummy_inputs(__lowerCAmelCase							)							)
							UpperCamelCase__								=						output.image_embeds

							UpperCamelCase__								=						pipe(
							    **self.get_dummy_inputs(__lowerCAmelCase							)     ,   return_dict=__lowerCAmelCase     ,   )[0]

							UpperCamelCase__								=						image[0, -10:]
							UpperCamelCase__								=						image_from_tuple[0, -10:]

							assert image.shape == (1, 32)

							UpperCamelCase__								=						np.array(
							    [
							        0.1_0_7_1_2_8_4,
							        1.3_3_3_0_2_7_1,
							        0.6_1_2_6_0_2_2_3,
							        -0.6_6_9_1_0_6_5,
							        -0.3_8_4_6_8_5_2,
							        -1.0_3_0_3_6_6_1,
							        0.2_2_7_1_6_1_1_1,
							        0.0_3_3_4_8_9_0_1,
							        0.3_0_0_4_0_6_7_5,
							        -0.2_4_8_0_5_0_2_9,
							    ]							)

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




					@skip_mps
					def 						snake_case_		(    self							)    ->	Optional[Any]:
							UpperCamelCase__								=						torch_device == """cpu"""
							UpperCamelCase__								=						True
							UpperCamelCase__								=						False

							self._test_inference_batch_single_identical(
							    test_max_difference=__lowerCAmelCase     ,   relax_max_difference=__lowerCAmelCase     ,   test_mean_pixel_difference=__lowerCAmelCase     ,   )




					@skip_mps
					def 						snake_case_		(    self							)    ->	Dict:
							UpperCamelCase__								=						torch_device == """cpu"""
							UpperCamelCase__								=						False

							self._test_attention_slicing_forward_pass(
							    test_max_difference=__lowerCAmelCase     ,   test_mean_pixel_difference=__lowerCAmelCase     ,   )












def      a    (   _lowercase :  Dict			,    _lowercase :  List[str]							)  ->List[Any]:
		if len(str(_lowercase							)							) == 1 or len(str(_lowercase							)							) == 1:
				return a * b

		UpperCamelCase__								=						max(len(str(_lowercase							)							)			,    len(str(_lowercase							)							)							)
		UpperCamelCase__								=						ma // 2

		UpperCamelCase__	,      UpperCamelCase__								=						divmod(_lowercase			,    1_0**ma							)
		UpperCamelCase__	,      UpperCamelCase__								=						divmod(_lowercase			,    1_0**ma							)

		UpperCamelCase__								=						karatsuba(_lowercase			,    _lowercase							)
		UpperCamelCase__								=						karatsuba((aa + aa)			,    (ba + ba)							)
		UpperCamelCase__								=						karatsuba(_lowercase			,    _lowercase							)

		return (z * 1_0 ** (2 * ma)) + ((y - z - x) * 1_0 ** (ma)) + (x)

def      a    (   )  ->List[Any]:
		print(karatsuba(1_5_4_6_3			,    2_3_4_8_9							)							)


if __name__ == "__main__":
				main()





