
"""simple docstring"""


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    __lowerCamelCase     (   SCREAMING_SNAKE_CASE__	,  unittest.TestCase):
				a__:			Tuple									=						KandinskyVaaPriorEmbaEmbPipeline
				a__:			int									=						['prompt', 'image']
				a__:			int									=						['prompt', 'image']
				a__:			Any									=						[
				    'num_images_per_prompt',
				    'strength',
				    'generator',
				    'num_inference_steps',
				    'latents',
				    'negative_prompt',
				    'guidance_scale',
				    'output_type',
				    'return_dict',
				]
				a__:			Tuple									=						False




				@property
				def 					UpperCAmelCase__	(							self      ):
							return 32




				@property
				def 					UpperCAmelCase__	(							self      ):
							return 32




				@property
				def 					UpperCAmelCase__	(							self      ):
							return self.time_input_dim




				@property
				def 					UpperCAmelCase__	(							self      ):
							return self.time_input_dim * 4




				@property
				def 					UpperCAmelCase__	(							self      ):
							return 100




				@property
				def 					UpperCAmelCase__	(							self      ):
							lowerCamelCase_ 		=     CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''      )
							return tokenizer




				@property
				def 					UpperCAmelCase__	(							self      ):
							torch.manual_seed(0      )
							lowerCamelCase_ 		=     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=1000       ,	)
							return CLIPTextModelWithProjection(a_      )




				@property
				def 					UpperCAmelCase__	(							self      ):
							torch.manual_seed(0      )

							lowerCamelCase_ 		=     {
							    '''num_attention_heads''': 2,
							    '''attention_head_dim''': 12,
							    '''embedding_dim''': self.text_embedder_hidden_size,
							    '''num_layers''': 1,
							}

							lowerCamelCase_ 		=     PriorTransformer(**a_      )
							# 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_ 		=     nn.Parameter(torch.ones(model.clip_std.shape      )      )
							return model




				@property
				def 					UpperCAmelCase__	(							self      ):
							torch.manual_seed(0      )
							lowerCamelCase_ 		=     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_ 		=     CLIPVisionModelWithProjection(a_      )
							return model




				@property
				def 					UpperCAmelCase__	(							self      ):
							lowerCamelCase_ 		=     CLIPImageProcessor(
							    crop_size=224       ,	do_center_crop=a_       ,	do_normalize=a_       ,	do_resize=a_       ,	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 					UpperCAmelCase__	(							self      ):
							lowerCamelCase_ 		=     self.dummy_prior
							lowerCamelCase_ 		=     self.dummy_image_encoder
							lowerCamelCase_ 		=     self.dummy_text_encoder
							lowerCamelCase_ 		=     self.dummy_tokenizer
							lowerCamelCase_ 		=     self.dummy_image_processor

							lowerCamelCase_ 		=     UnCLIPScheduler(
							    variance_type='''fixed_small_log'''       ,	prediction_type='''sample'''       ,	num_train_timesteps=1000       ,	clip_sample=a_       ,	clip_sample_range=1_0.0       ,	)

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

							return components




				def 					UpperCAmelCase__	(							self       ,	UpperCAmelCase       ,	UpperCAmelCase=0      ):



							if str(a_      ).startswith('''mps'''      ):
										lowerCamelCase_ 		=     torch.manual_seed(a_      )
							else:
										lowerCamelCase_ 		=     torch.Generator(device=a_      ).manual_seed(a_      )

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

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




				def 					UpperCAmelCase__	(							self      ):
							lowerCamelCase_ 		=     '''cpu'''

							lowerCamelCase_ 		=     self.get_dummy_components()

							lowerCamelCase_ 		=     self.pipeline_class(**a_      )
							lowerCamelCase_ 		=     pipe.to(a_      )

							pipe.set_progress_bar_config(disable=a_      )

							lowerCamelCase_ 		=     pipe(**self.get_dummy_inputs(a_      )      )
							lowerCamelCase_ 		=     output.image_embeds

							lowerCamelCase_ 		=     pipe(
							    **self.get_dummy_inputs(a_      )       ,	return_dict=a_       ,	)[0]

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

							assert image.shape == (1, 32)

							lowerCamelCase_ 		=     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 					UpperCAmelCase__	(							self      ):
							lowerCamelCase_ 		=     torch_device == '''cpu'''
							lowerCamelCase_ 		=     True
							lowerCamelCase_ 		=     False

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





				@skip_mps
				def 					UpperCAmelCase__	(							self      ):
							lowerCamelCase_ 		=     torch_device == '''cpu'''
							lowerCamelCase_ 		=     False

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





"""simple docstring"""


from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


A_						       =				{
    """configuration_flava""": [
        """FLAVA_PRETRAINED_CONFIG_ARCHIVE_MAP""",
        """FlavaConfig""",
        """FlavaImageCodebookConfig""",
        """FlavaImageConfig""",
        """FlavaMultimodalConfig""",
        """FlavaTextConfig""",
    ],
}

try:
						if not is_vision_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						A_						       =				["""FlavaFeatureExtractor"""]
						A_						       =				["""FlavaImageProcessor"""]
						A_						       =				["""FlavaProcessor"""]

try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						A_						       =				[
						    """FLAVA_PRETRAINED_MODEL_ARCHIVE_LIST""",
						    """FlavaForPreTraining""",
						    """FlavaImageCodebook""",
						    """FlavaImageModel""",
						    """FlavaModel""",
						    """FlavaMultimodalModel""",
						    """FlavaPreTrainedModel""",
						    """FlavaTextModel""",
						]

if TYPE_CHECKING:
						from .configuration_flava import (
						    FLAVA_PRETRAINED_CONFIG_ARCHIVE_MAP,
						    FlavaConfig,
						    FlavaImageCodebookConfig,
						    FlavaImageConfig,
						    FlavaMultimodalConfig,
						    FlavaTextConfig,
						)

						try:
												if not is_vision_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .feature_extraction_flava import FlavaFeatureExtractor
												from .image_processing_flava import FlavaImageProcessor
												from .processing_flava import FlavaProcessor

						try:
												if not is_torch_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_flava import (
												    FLAVA_PRETRAINED_MODEL_ARCHIVE_LIST,
												    FlavaForPreTraining,
												    FlavaImageCodebook,
												    FlavaImageModel,
												    FlavaModel,
												    FlavaMultimodalModel,
												    FlavaPreTrainedModel,
												    FlavaTextModel,
												)

else:
						import sys

						A_						       =				_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)



