
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 						lowercase       (  A_	,		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 lowercase_			(		self    ):
								"""simple docstring"""







								return 32
					@property
					def lowercase_			(		self    ):
								"""simple docstring"""







								return 32
					@property
					def lowercase_			(		self    ):
								"""simple docstring"""







								return self.time_input_dim
					@property
					def lowercase_			(		self    ):
								"""simple docstring"""







								return self.time_input_dim * 4
					@property
					def lowercase_			(		self    ):
								"""simple docstring"""







								return 100
					@property
					def lowercase_			(		self    ):
								"""simple docstring"""







								lowerCAmelCase__ :    Union[str, Any]				      =			CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''    )
								return tokenizer
					@property
					def lowercase_			(		self    ):
								"""simple docstring"""







								torch.manual_seed(0    )
								lowerCAmelCase__ :    Dict				      =			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-05 ,	num_attention_heads=4 ,	num_hidden_layers=5 ,	pad_token_id=1 ,	vocab_size=1000 ,	)
								return CLIPTextModelWithProjection(SCREAMING_SNAKE_CASE__    )
					@property
					def lowercase_			(		self    ):
								"""simple docstring"""







								torch.manual_seed(0    )

								lowerCAmelCase__ :    Optional[int]				      =			{
								    '''num_attention_heads''': 2,
								    '''attention_head_dim''': 12,
								    '''embedding_dim''': self.text_embedder_hidden_size,
								    '''num_layers''': 1,
								}

								lowerCAmelCase__ :    List[Any]				      =			PriorTransformer(**SCREAMING_SNAKE_CASE__    )
								# 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
								lowerCAmelCase__ :    List[str]				      =			nn.Parameter(torch.ones(model.clip_std.shape    )    )
								return model
					@property
					def lowercase_			(		self    ):
								"""simple docstring"""







								torch.manual_seed(0    )
								lowerCAmelCase__ :    Dict				      =			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 ,	)

								lowerCAmelCase__ :    Dict				      =			CLIPVisionModelWithProjection(SCREAMING_SNAKE_CASE__    )
								return model
					@property
					def lowercase_			(		self    ):
								"""simple docstring"""







								lowerCAmelCase__ :    Optional[Any]				      =			CLIPImageProcessor(
								    crop_size=224 ,	do_center_crop=SCREAMING_SNAKE_CASE__ ,	do_normalize=SCREAMING_SNAKE_CASE__ ,	do_resize=SCREAMING_SNAKE_CASE__ ,	image_mean=[0.48_145_466, 0.4_578_275, 0.40_821_073] ,	image_std=[0.26_862_954, 0.26_130_258, 0.27_577_711] ,	resample=3 ,	size=224 ,	)

								return image_processor
					def lowercase_			(		self    ):
								"""simple docstring"""







								lowerCAmelCase__ :    str				      =			self.dummy_prior
								lowerCAmelCase__ :    str				      =			self.dummy_image_encoder
								lowerCAmelCase__ :    Optional[Any]				      =			self.dummy_text_encoder
								lowerCAmelCase__ :    str				      =			self.dummy_tokenizer
								lowerCAmelCase__ :    List[Any]				      =			self.dummy_image_processor

								lowerCAmelCase__ :    Union[str, Any]				      =			UnCLIPScheduler(
								    variance_type='''fixed_small_log''' ,	prediction_type='''sample''' ,	num_train_timesteps=1000 ,	clip_sample=SCREAMING_SNAKE_CASE__ ,	clip_sample_range=10.0 ,	)

								lowerCAmelCase__ :    Any				      =			{
								    '''prior''': prior,
								    '''image_encoder''': image_encoder,
								    '''text_encoder''': text_encoder,
								    '''tokenizer''': tokenizer,
								    '''scheduler''': scheduler,
								    '''image_processor''': image_processor,
								}

								return components
					def lowercase_			(		self ,	SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__=0    ):
								"""simple docstring"""







								if str(SCREAMING_SNAKE_CASE__    ).startswith('''mps'''    ):
											lowerCAmelCase__ :    str				      =			torch.manual_seed(SCREAMING_SNAKE_CASE__    )
								else:
											lowerCAmelCase__ :    Optional[int]				      =			torch.Generator(device=SCREAMING_SNAKE_CASE__    ).manual_seed(SCREAMING_SNAKE_CASE__    )

								lowerCAmelCase__ :    List[Any]				      =			floats_tensor((1, 3, 64, 64) ,	rng=random.Random(SCREAMING_SNAKE_CASE__    )    ).to(SCREAMING_SNAKE_CASE__    )
								lowerCAmelCase__ :    List[Any]				      =			image.cpu().permute(0 ,	2 ,	3 ,	1    )[0]
								lowerCAmelCase__ :    Optional[int]				      =			Image.fromarray(np.uinta(SCREAMING_SNAKE_CASE__    )    ).convert('''RGB'''    ).resize((256, 256)    )

								lowerCAmelCase__ :    str				      =			{
								    '''prompt''': '''horse''',
								    '''image''': init_image,
								    '''strength''': 0.5,
								    '''generator''': generator,
								    '''guidance_scale''': 4.0,
								    '''num_inference_steps''': 2,
								    '''output_type''': '''np''',
								}
								return inputs
					def lowercase_			(		self    ):
								"""simple docstring"""







								lowerCAmelCase__ :    Union[str, Any]				      =			'''cpu'''

								lowerCAmelCase__ :    str				      =			self.get_dummy_components()

								lowerCAmelCase__ :    Any				      =			self.pipeline_class(**SCREAMING_SNAKE_CASE__    )
								lowerCAmelCase__ :    List[str]				      =			pipe.to(SCREAMING_SNAKE_CASE__    )

								pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE__    )

								lowerCAmelCase__ :    int				      =			pipe(**self.get_dummy_inputs(SCREAMING_SNAKE_CASE__    )    )
								lowerCAmelCase__ :    str				      =			output.image_embeds

								lowerCAmelCase__ :    Dict				      =			pipe(
								    **self.get_dummy_inputs(SCREAMING_SNAKE_CASE__    ) ,	return_dict=SCREAMING_SNAKE_CASE__ ,	)[0]

								lowerCAmelCase__ :    Optional[Any]				      =			image[0, -10:]
								lowerCAmelCase__ :    Union[str, Any]				      =			image_from_tuple[0, -10:]

								assert image.shape == (1, 32)

								lowerCAmelCase__ :    str				      =			np.array(
								    [
								        0.1_071_284,
								        1.3_330_271,
								        0.61_260_223,
								        -0.6_691_065,
								        -0.3_846_852,
								        -1.0_303_661,
								        0.22_716_111,
								        0.03_348_901,
								        0.30_040_675,
								        -0.24_805_029,
								    ]    )

								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 lowercase_			(		self    ):
								"""simple docstring"""







								lowerCAmelCase__ :    Union[str, Any]				      =			torch_device == '''cpu'''
								lowerCAmelCase__ :    Dict				      =			True
								lowerCAmelCase__ :    List[str]				      =			False

								self._test_inference_batch_single_identical(
								    test_max_difference=SCREAMING_SNAKE_CASE__ ,	relax_max_difference=SCREAMING_SNAKE_CASE__ ,	test_mean_pixel_difference=SCREAMING_SNAKE_CASE__ ,	)
					@skip_mps
					def lowercase_			(		self    ):
								"""simple docstring"""







								lowerCAmelCase__ :    Tuple				      =			torch_device == '''cpu'''
								lowerCAmelCase__ :    Tuple				      =			False

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





import unittest
from pathlib import Path
from tempfile import TemporaryDirectory
from unittest.mock import Mock, patch

import diffusers.utils.hub_utils





class 						lowercase       (  unittest.TestCase					):
					@patch('''diffusers.utils.hub_utils.get_full_repo_name'''    )
					def lowercase_			(		self ,	SCREAMING_SNAKE_CASE__    ):
								"""simple docstring"""







								lowerCAmelCase__ :    str				      =			'''full_repo_name'''
								with TemporaryDirectory() as tmpdir:
											# Dummy args values
											lowerCAmelCase__ :    Optional[int]				      =			Mock()
											lowerCAmelCase__ :    Optional[int]				      =			tmpdir
											lowerCAmelCase__ :    Optional[Any]				      =			0
											lowerCAmelCase__ :    Optional[int]				      =			'''hub_token'''
											lowerCAmelCase__ :    Tuple				      =			'''dataset_name'''
											lowerCAmelCase__ :    int				      =			0.01
											lowerCAmelCase__ :    Optional[int]				      =			100000
											lowerCAmelCase__ :    Any				      =			10000
											lowerCAmelCase__ :    Union[str, Any]				      =			0.01
											lowerCAmelCase__ :    int				      =			0.02
											lowerCAmelCase__ :    Union[str, Any]				      =			0.03
											lowerCAmelCase__ :    str				      =			0.0_005
											lowerCAmelCase__ :    Dict				      =			0.000_001
											lowerCAmelCase__ :    Tuple				      =			1
											lowerCAmelCase__ :    Optional[int]				      =			10
											lowerCAmelCase__ :    int				      =			0.001
											lowerCAmelCase__ :    Union[str, Any]				      =			0.1
											lowerCAmelCase__ :    Tuple				      =			0.2
											lowerCAmelCase__ :    Optional[int]				      =			True

											# Model card mush be rendered and saved
											diffusers.utils.hub_utils.create_model_card(SCREAMING_SNAKE_CASE__ ,	model_name='''model_name'''    )
											self.assertTrue((Path(SCREAMING_SNAKE_CASE__    ) / '''README.md''').is_file()    )



