

"""simple docstring"""






lowerCamelCase__			:					int							  =					10_00
def  UpperCamelCase   (     _lowerCAmelCase       :  float	)			->     float:
	return x * x
def  UpperCamelCase   (     _lowerCAmelCase       :  Optional[Any],					_lowerCAmelCase       :  float,					_lowerCAmelCase       :  float,					_lowerCAmelCase       :  int = 4	)			->     float:
	assert callable(
	    _lowerCAmelCase	), f'''the function(object) passed should be callable your input : {function}'''
	assert isinstance(_lowerCAmelCase,					(float, int)	), f'''a should be float or integer your input : {a}'''
	assert isinstance(function(_lowerCAmelCase	),					(float, int)	), (
	    "the function should return integer or float return type of your function, "
	    f'''{type(_lowerCAmelCase	)}'''
	)
	assert isinstance(_lowerCAmelCase,					(float, int)	), f'''b should be float or integer your input : {b}'''
	assert (
	    isinstance(_lowerCAmelCase,					_lowerCAmelCase	) and precision > 0
	), f'''precision should be positive integer your input : {precision}'''

	# just applying the formula of simpson for approximate integration written in
	# mentioned article in first comment of this file and above this function

	_UpperCAmelCase      :							Any       =   (b - a) / N_STEPS
	_UpperCAmelCase      :							int       =   function(_lowerCAmelCase	) + function(_lowerCAmelCase	)

	for i in range(1,					_lowerCAmelCase	):
		_UpperCAmelCase      :							Tuple       =   a + h * i
		result += function(_lowerCAmelCase	) * (4 if i % 2 else 2)

	result *= h / 3
	return round(_lowerCAmelCase,					_lowerCAmelCase	)


if __name__ == "__main__":
						import doctest

						doctest.testmod()








"""simple docstring"""






import unittest

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

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

from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()






class       _UpperCAmelCase     (						__a      ,       unittest.TestCase):
			__a	:    List[Any]			   =							KandinskyPriorPipeline
			__a	:    List[Any]			   =							["""prompt"""]
			__a	:    List[str]			   =							["""prompt""", """negative_prompt"""]
			__a	:    Tuple			   =							[
			    """num_images_per_prompt""",
			    """generator""",
			    """num_inference_steps""",
			    """latents""",
			    """negative_prompt""",
			    """guidance_scale""",
			    """output_type""",
			    """return_dict""",
			]
			__a	:    str			   =							False
			@property
			def 							__snake_case	(						self       )      ->      Any:






				'''simple docstring'''







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






				'''simple docstring'''







				return 32
			@property
			def 							__snake_case	(						self       )      ->      Dict:






				'''simple docstring'''







				return self.time_input_dim
			@property
			def 							__snake_case	(						self       )      ->      Optional[Any]:






				'''simple docstring'''







				return self.time_input_dim * 4
			@property
			def 							__snake_case	(						self       )      ->      List[Any]:






				'''simple docstring'''







				return 1_00
			@property
			def 							__snake_case	(						self       )      ->      Optional[int]:






				'''simple docstring'''







				_UpperCAmelCase      :							List[str]       =   CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""       )
				return tokenizer
			@property
			def 							__snake_case	(						self       )      ->      int:






				'''simple docstring'''







				torch.manual_seed(0       )
				_UpperCAmelCase      :							List[Any]       =   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=10_00 ,						)
				return CLIPTextModelWithProjection(_A       )
			@property
			def 							__snake_case	(						self       )      ->      List[Any]:






				'''simple docstring'''







				torch.manual_seed(0       )

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

				_UpperCAmelCase      :							List[Any]       =   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
				_UpperCAmelCase      :							List[Any]       =   nn.Parameter(torch.ones(model.clip_std.shape       )       )
				return model
			@property
			def 							__snake_case	(						self       )      ->      Dict:






				'''simple docstring'''







				torch.manual_seed(0       )
				_UpperCAmelCase      :							Optional[Any]       =   CLIPVisionConfig(
				    hidden_size=self.text_embedder_hidden_size ,						image_size=2_24 ,						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      :							Tuple       =   CLIPVisionModelWithProjection(_A       )
				return model
			@property
			def 							__snake_case	(						self       )      ->      List[str]:






				'''simple docstring'''







				_UpperCAmelCase      :							str       =   CLIPImageProcessor(
				    crop_size=2_24 ,						do_center_crop=_A ,						do_normalize=_A ,						do_resize=_A ,						image_mean=[0.48145466, 0.4578275, 0.40821073] ,						image_std=[0.26862954, 0.26130258, 0.27577711] ,						resample=3 ,						size=2_24 ,						)

				return image_processor
			def 							__snake_case	(						self       )      ->      Dict:






				'''simple docstring'''







				_UpperCAmelCase      :							Optional[int]       =   self.dummy_prior
				_UpperCAmelCase      :							int       =   self.dummy_image_encoder
				_UpperCAmelCase      :							int       =   self.dummy_text_encoder
				_UpperCAmelCase      :							str       =   self.dummy_tokenizer
				_UpperCAmelCase      :							Any       =   self.dummy_image_processor

				_UpperCAmelCase      :							Any       =   UnCLIPScheduler(
				    variance_type="""fixed_small_log""" ,						prediction_type="""sample""" ,						num_train_timesteps=10_00 ,						clip_sample=_A ,						clip_sample_range=10.0 ,						)

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

				return components
			def 							__snake_case	(						self ,						_A ,						_A=0       )      ->      Optional[Any]:






				'''simple docstring'''







				if str(_A       ).startswith("""mps"""       ):
					_UpperCAmelCase      :							Any       =   torch.manual_seed(_A       )
				else:
					_UpperCAmelCase      :							Optional[int]       =   torch.Generator(device=_A       ).manual_seed(_A       )
				_UpperCAmelCase      :							Union[str, Any]       =   {
				    """prompt""": """horse""",
				    """generator""": generator,
				    """guidance_scale""": 4.0,
				    """num_inference_steps""": 2,
				    """output_type""": """np""",
				}
				return inputs
			def 							__snake_case	(						self       )      ->      Union[str, Any]:






				'''simple docstring'''







				_UpperCAmelCase      :							List[str]       =   """cpu"""

				_UpperCAmelCase      :							int       =   self.get_dummy_components()

				_UpperCAmelCase      :							Optional[Any]       =   self.pipeline_class(**_A       )
				_UpperCAmelCase      :							List[Any]       =   pipe.to(_A       )

				pipe.set_progress_bar_config(disable=_A       )

				_UpperCAmelCase      :							str       =   pipe(**self.get_dummy_inputs(_A       )       )
				_UpperCAmelCase      :							Any       =   output.image_embeds

				_UpperCAmelCase      :							Optional[int]       =   pipe(
				    **self.get_dummy_inputs(_A       ) ,						return_dict=_A ,						)[0]

				_UpperCAmelCase      :							int       =   image[0, -10:]
				_UpperCAmelCase      :							Optional[Any]       =   image_from_tuple[0, -10:]

				assert image.shape == (1, 32)

				_UpperCAmelCase      :							Optional[Any]       =   np.array(
				    [-0.0532, 1.7120, 0.3656, -1.0852, -0.8946, -1.1756, 0.4348, 0.2482, 0.5146, -0.1156]       )

				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       )      ->      Tuple:






				'''simple docstring'''







				_UpperCAmelCase      :							str       =   torch_device == """cpu"""
				_UpperCAmelCase      :							Optional[Any]       =   True
				_UpperCAmelCase      :							List[Any]       =   False

				self._test_inference_batch_single_identical(
				    test_max_difference=_A ,						relax_max_difference=_A ,						test_mean_pixel_difference=_A ,						)
			@skip_mps
			def 							__snake_case	(						self       )      ->      Any:






				'''simple docstring'''







				_UpperCAmelCase      :							Any       =   torch_device == """cpu"""
				_UpperCAmelCase      :							List[str]       =   False

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





