


from typing import Dict, List, Optional, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import center_crop, normalize, rescale, resize, to_channel_dimension_format
from ...image_utils import (
    IMAGENET_STANDARD_MEAN,
    IMAGENET_STANDARD_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_vision_available, logging


if is_vision_available():
							import PIL


snake_case_  :     Tuple							  =							logging.get_logger(__name__)

class   A__							(						lowerCamelCase__					):
						UpperCAmelCase     =  ['pixel_values']




						def __init__(    self   : Any			,      _a   : int = True			,      _a   : Optional[Any] = None			,      _a   : Tuple = PIL.Image.NEAREST			,      _a   : int = False			,      _a   : List[str] = None			,      _a   : Optional[Any] = 1 / 255			,      _a   : List[str] = False			,      _a   : Optional[Any] = True			,      _a   : Tuple = True			,      _a   : Union[str, Any] = None			,      _a   : Tuple = None			,      _a   : List[str] = True			,      **_a   : str			,      )							->       None:


										"""simple docstring"""





										super().__init__(**lowercase_					)
										_SCREAMING_SNAKE_CASE     					=size if size is not None else {'''height''': 346, '''width''': 346}
										_SCREAMING_SNAKE_CASE     					=get_size_dict(lowercase_					)
										_SCREAMING_SNAKE_CASE     					=crop_size if crop_size is not None else {'''height''': 289, '''width''': 289}
										_SCREAMING_SNAKE_CASE     					=get_size_dict(lowercase_			,      param_name='''crop_size'''					)

										_SCREAMING_SNAKE_CASE     					=do_resize
										_SCREAMING_SNAKE_CASE     					=size
										_SCREAMING_SNAKE_CASE     					=resample
										_SCREAMING_SNAKE_CASE     					=do_center_crop
										_SCREAMING_SNAKE_CASE     					=crop_size
										_SCREAMING_SNAKE_CASE     					=do_rescale
										_SCREAMING_SNAKE_CASE     					=rescale_factor
										_SCREAMING_SNAKE_CASE     					=rescale_offset
										_SCREAMING_SNAKE_CASE     					=do_normalize
										_SCREAMING_SNAKE_CASE     					=image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
										_SCREAMING_SNAKE_CASE     					=image_std if image_std is not None else IMAGENET_STANDARD_STD
										_SCREAMING_SNAKE_CASE     					=include_top




						def 							__UpperCamelCase			(    self   : Tuple			,      _a   : Any			,      _a   : Optional[int]			,      _a   : str = PIL.Image.NEAREST			,      _a   : Dict = None			,      **_a   : Optional[int]			,      )							->       np.ndarray:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE     					=get_size_dict(lowercase_					)
										if "height" not in size or "width" not in size:
														raise ValueError(f"The size dictionary must have keys 'height' and 'width'. Got {size.keys()}"					)
										return resize(
										    lowercase_			,      size=(size['''height'''], size['''width'''])			,      resample=lowercase_			,      data_format=lowercase_			,      **lowercase_					)




						def 							__UpperCamelCase			(    self   : Union[str, Any]			,      _a   : Tuple			,      _a   : int			,      _a   : List[str] = None			,      **_a   : List[Any]			,      )							->       np.ndarray:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE     					=get_size_dict(lowercase_					)
										if "height" not in size or "width" not in size:
														raise ValueError(f"The size dictionary must have keys 'height' and 'width'. Got {size.keys()}"					)
										return center_crop(lowercase_			,      size=(size['''height'''], size['''width'''])			,      data_format=lowercase_			,      **lowercase_					)




						def 							__UpperCamelCase			(    self   : Dict			,      _a   : Optional[Any]			,      _a   : Tuple			,      _a   : Union[str, Any] = True			,      _a   : List[str] = None			,      **_a   : str			,      )							->       str:


										"""simple docstring"""





										if offset:
														_SCREAMING_SNAKE_CASE     					=(image - 1_27.5) * scale
														if data_format is not None:
																		_SCREAMING_SNAKE_CASE     					=to_channel_dimension_format(lowercase_			,      lowercase_					)
														_SCREAMING_SNAKE_CASE     					=rescaled_image.astype(np.floataa					)
										else:
														_SCREAMING_SNAKE_CASE     					=rescale(lowercase_			,      scale=lowercase_			,      data_format=lowercase_			,      **lowercase_					)
										return rescaled_image




						def 							__UpperCamelCase			(    self   : int			,      _a   : List[Any]			,      _a   : List[str]			,      _a   : Dict			,      _a   : Optional[Any] = None			,      **_a   : Tuple			,      )							->       np.ndarray:


										"""simple docstring"""





										return normalize(lowercase_			,      mean=lowercase_			,      std=lowercase_			,      data_format=lowercase_			,      **lowercase_					)




						def 							__UpperCamelCase			(    self   : int			,      _a   : Optional[Any]			,      _a   : Union[str, Any] = None			,      _a   : Union[str, Any] = None			,      _a   : List[str]=None			,      _a   : Dict = None			,      _a   : Dict = None			,      _a   : str = None			,      _a   : Optional[int] = None			,      _a   : str = None			,      _a   : List[str] = None			,      _a   : Any = None			,      _a   : Dict = None			,      _a   : Tuple = None			,      _a   : int = None			,      _a   : List[Any] = ChannelDimension.FIRST			,      **_a   : Optional[int]			,      )							->       PIL.Image.Image:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE     					=do_resize if do_resize is not None else self.do_resize
										_SCREAMING_SNAKE_CASE     					=resample if resample is not None else self.resample
										_SCREAMING_SNAKE_CASE     					=do_center_crop if do_center_crop is not None else self.do_center_crop
										_SCREAMING_SNAKE_CASE     					=do_rescale if do_rescale is not None else self.do_rescale
										_SCREAMING_SNAKE_CASE     					=rescale_factor if rescale_factor is not None else self.rescale_factor
										_SCREAMING_SNAKE_CASE     					=rescale_offset if rescale_offset is not None else self.rescale_offset
										_SCREAMING_SNAKE_CASE     					=do_normalize if do_normalize is not None else self.do_normalize
										_SCREAMING_SNAKE_CASE     					=image_mean if image_mean is not None else self.image_mean
										_SCREAMING_SNAKE_CASE     					=image_std if image_std is not None else self.image_std
										_SCREAMING_SNAKE_CASE     					=include_top if include_top is not None else self.include_top

										_SCREAMING_SNAKE_CASE     					=size if size is not None else self.size
										_SCREAMING_SNAKE_CASE     					=get_size_dict(lowercase_					)
										_SCREAMING_SNAKE_CASE     					=crop_size if crop_size is not None else self.crop_size
										_SCREAMING_SNAKE_CASE     					=get_size_dict(lowercase_			,      param_name='''crop_size'''					)

										_SCREAMING_SNAKE_CASE     					=make_list_of_images(lowercase_					)

										if not valid_images(lowercase_					):
														raise ValueError(
														    '''Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, '''
														    '''torch.Tensor, tf.Tensor or jax.ndarray.'''					)

										if do_resize and size is None or resample is None:
														raise ValueError('''Size and resample must be specified if do_resize is True.'''					)

										if do_center_crop and crop_size is None:
														raise ValueError('''Crop size must be specified if do_center_crop is True.'''					)

										if do_rescale and rescale_factor is None:
														raise ValueError('''Rescale factor must be specified if do_rescale is True.'''					)

										if do_normalize and (image_mean is None or image_std is None):
														raise ValueError('''Image mean and std must be specified if do_normalize is True.'''					)

										# All transformations expect numpy arrays.
										_SCREAMING_SNAKE_CASE     					=[to_numpy_array(lowercase_					) for image in images]

										if do_resize:
														_SCREAMING_SNAKE_CASE     					=[self.resize(image=lowercase_			,      size=lowercase_			,      resample=lowercase_					) for image in images]

										if do_center_crop:
														_SCREAMING_SNAKE_CASE     					=[self.center_crop(image=lowercase_			,      size=lowercase_					) for image in images]

										if do_rescale:
														_SCREAMING_SNAKE_CASE     					=[self.rescale(image=lowercase_			,      scale=lowercase_			,      offset=lowercase_					) for image in images]

										if do_normalize:
														_SCREAMING_SNAKE_CASE     					=[self.normalize(image=lowercase_			,      mean=lowercase_			,      std=lowercase_					) for image in images]

										if include_top:
														_SCREAMING_SNAKE_CASE     					=[self.normalize(image=lowercase_			,      mean=[0, 0, 0]			,      std=lowercase_					) for image in images]

										_SCREAMING_SNAKE_CASE     					=[to_channel_dimension_format(lowercase_			,      lowercase_					) for image in images]

										_SCREAMING_SNAKE_CASE     					={'''pixel_values''': images}
										return BatchFeature(data=lowercase_			,      tensor_type=lowercase_					)



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   A__							(						UpperCamelCase__				,       unittest.TestCase					):
						UpperCAmelCase     =  KandinskyPriorPipeline
						UpperCAmelCase     =  ["prompt"]
						UpperCAmelCase     =  ["prompt", "negative_prompt"]
						UpperCAmelCase     =  [
						    "num_images_per_prompt",
						    "generator",
						    "num_inference_steps",
						    "latents",
						    "negative_prompt",
						    "guidance_scale",
						    "output_type",
						    "return_dict",
						]
						UpperCAmelCase     =  False




						@property
						def 							__UpperCamelCase			(    self   : Tuple					)							->       Tuple:


										"""simple docstring"""





										return 32




						@property
						def 							__UpperCamelCase			(    self   : Optional[int]					)							->       Tuple:


										"""simple docstring"""





										return 32




						@property
						def 							__UpperCamelCase			(    self   : Tuple					)							->       int:


										"""simple docstring"""





										return self.time_input_dim




						@property
						def 							__UpperCamelCase			(    self   : Optional[Any]					)							->       Any:


										"""simple docstring"""





										return self.time_input_dim * 4




						@property
						def 							__UpperCamelCase			(    self   : List[str]					)							->       str:


										"""simple docstring"""





										return 100




						@property
						def 							__UpperCamelCase			(    self   : List[Any]					)							->       List[str]:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE     					=CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''					)
										return tokenizer




						@property
						def 							__UpperCamelCase			(    self   : Any					)							->       Dict:


										"""simple docstring"""





										torch.manual_seed(0					)
										_SCREAMING_SNAKE_CASE     					=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(_a					)




						@property
						def 							__UpperCamelCase			(    self   : int					)							->       Any:


										"""simple docstring"""





										torch.manual_seed(0					)

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

										_SCREAMING_SNAKE_CASE     					=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
										_SCREAMING_SNAKE_CASE     					=nn.Parameter(torch.ones(model.clip_std.shape					)					)
										return model




						@property
						def 							__UpperCamelCase			(    self   : List[str]					)							->       Optional[Any]:


										"""simple docstring"""





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

										_SCREAMING_SNAKE_CASE     					=CLIPVisionModelWithProjection(_a					)
										return model




						@property
						def 							__UpperCamelCase			(    self   : Any					)							->       int:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE     					=CLIPImageProcessor(
										    crop_size=224			,      do_center_crop=_a			,      do_normalize=_a			,      do_resize=_a			,      image_mean=[0.48_14_54_66, 0.4_57_82_75, 0.40_82_10_73]			,      image_std=[0.26_86_29_54, 0.26_13_02_58, 0.27_57_77_11]			,      resample=3			,      size=224			,      )

										return image_processor




						def 							__UpperCamelCase			(    self   : int					)							->       Optional[int]:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE     					=self.dummy_prior
										_SCREAMING_SNAKE_CASE     					=self.dummy_image_encoder
										_SCREAMING_SNAKE_CASE     					=self.dummy_text_encoder
										_SCREAMING_SNAKE_CASE     					=self.dummy_tokenizer
										_SCREAMING_SNAKE_CASE     					=self.dummy_image_processor

										_SCREAMING_SNAKE_CASE     					=UnCLIPScheduler(
										    variance_type='''fixed_small_log'''			,      prediction_type='''sample'''			,      num_train_timesteps=1000			,      clip_sample=_a			,      clip_sample_range=10.0			,      )

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

										return components




						def 							__UpperCamelCase			(    self   : Optional[Any]			,      _a   : Tuple			,      _a   : str=0					)							->       Any:


										"""simple docstring"""





										if str(_a					).startswith('''mps'''					):
														_SCREAMING_SNAKE_CASE     					=torch.manual_seed(_a					)
										else:
														_SCREAMING_SNAKE_CASE     					=torch.Generator(device=_a					).manual_seed(_a					)
										_SCREAMING_SNAKE_CASE     					={
										    '''prompt''': '''horse''',
										    '''generator''': generator,
										    '''guidance_scale''': 4.0,
										    '''num_inference_steps''': 2,
										    '''output_type''': '''np''',
										}
										return inputs




						def 							__UpperCamelCase			(    self   : Optional[int]					)							->       Tuple:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE     					='''cpu'''

										_SCREAMING_SNAKE_CASE     					=self.get_dummy_components()

										_SCREAMING_SNAKE_CASE     					=self.pipeline_class(**_a					)
										_SCREAMING_SNAKE_CASE     					=pipe.to(_a					)

										pipe.set_progress_bar_config(disable=_a					)

										_SCREAMING_SNAKE_CASE     					=pipe(**self.get_dummy_inputs(_a					)					)
										_SCREAMING_SNAKE_CASE     					=output.image_embeds

										_SCREAMING_SNAKE_CASE     					=pipe(
										    **self.get_dummy_inputs(_a					)			,      return_dict=_a			,      )[0]

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

										assert image.shape == (1, 32)

										_SCREAMING_SNAKE_CASE     					=np.array(
										    [-0.05_32, 1.71_20, 0.36_56, -1.08_52, -0.89_46, -1.17_56, 0.43_48, 0.24_82, 0.51_46, -0.11_56]					)

										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   : List[str]					)							->       List[Any]:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE     					=torch_device == '''cpu'''
										_SCREAMING_SNAKE_CASE     					=True
										_SCREAMING_SNAKE_CASE     					=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   : List[Any]					)							->       str:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE     					=torch_device == '''cpu'''
										_SCREAMING_SNAKE_CASE     					=False

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