



'''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 KandinskyVaaPriorPipeline, 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 	lowerCamelCase_							(					snake_case_    ,				unittest.TestCase			):
						_lowerCAmelCase     :   Union[str, Any]	     =				KandinskyVaaPriorPipeline
						_lowerCAmelCase     :   Dict	     =				['prompt']
						_lowerCAmelCase     :   List[str]	     =				['prompt', 'negative_prompt']
						_lowerCAmelCase     :   Optional[int]	     =				[
						    'num_images_per_prompt',
						    'generator',
						    'num_inference_steps',
						    'latents',
						    'negative_prompt',
						    'guidance_scale',
						    'output_type',
						    'return_dict',
						]
						_lowerCAmelCase     :   Dict	     =				False







						@property
						def 					__lowercase    (  self   :      str				):

													"""simple docstring"""
													return 32







						@property
						def 					__lowercase    (  self   :      List[Any]				):

													"""simple docstring"""
													return 32







						@property
						def 					__lowercase    (  self   :      Tuple				):

													"""simple docstring"""
													return self.time_input_dim







						@property
						def 					__lowercase    (  self   :      str				):

													"""simple docstring"""
													return self.time_input_dim * 4







						@property
						def 					__lowercase    (  self   :      Dict				):

													"""simple docstring"""
													return 1_00







						@property
						def 					__lowercase    (  self   :      Optional[Any]				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      List[Any]     					=			CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''				)
													return tokenizer







						@property
						def 					__lowercase    (  self   :      int				):

													"""simple docstring"""
													torch.manual_seed(0				)
													SCREAMING_SNAKE_CASE					:      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(lowerCAmelCase__				)







						@property
						def 					__lowercase    (  self   :      Optional[Any]				):

													"""simple docstring"""
													torch.manual_seed(0				)

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

													SCREAMING_SNAKE_CASE					:      Optional[int]     					=			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
													SCREAMING_SNAKE_CASE					:      Optional[Any]     					=			nn.Parameter(torch.ones(model.clip_std.shape				)				)
													return model







						@property
						def 					__lowercase    (  self   :      Tuple				):

													"""simple docstring"""
													torch.manual_seed(0				)
													SCREAMING_SNAKE_CASE					:      Dict     					=			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				,    )

													SCREAMING_SNAKE_CASE					:      Tuple     					=			CLIPVisionModelWithProjection(lowerCAmelCase__				)
													return model







						@property
						def 					__lowercase    (  self   :      str				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      Dict     					=			CLIPImageProcessor(
													    crop_size=2_24				,    do_center_crop=lowerCAmelCase__				,    do_normalize=lowerCAmelCase__				,    do_resize=lowerCAmelCase__				,    image_mean=[0.4814_5466, 0.457_8275, 0.4082_1073]				,    image_std=[0.2686_2954, 0.2613_0258, 0.2757_7711]				,    resample=3				,    size=2_24				,    )

													return image_processor







						def 					__lowercase    (  self   :      Union[str, Any]				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      str     					=			self.dummy_prior
													SCREAMING_SNAKE_CASE					:      Optional[Any]     					=			self.dummy_image_encoder
													SCREAMING_SNAKE_CASE					:      Dict     					=			self.dummy_text_encoder
													SCREAMING_SNAKE_CASE					:      Optional[Any]     					=			self.dummy_tokenizer
													SCREAMING_SNAKE_CASE					:      List[str]     					=			self.dummy_image_processor

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

													SCREAMING_SNAKE_CASE					:      List[str]     					=			{
													    '''prior''': prior,
													    '''image_encoder''': image_encoder,
													    '''text_encoder''': text_encoder,
													    '''tokenizer''': tokenizer,
													    '''scheduler''': scheduler,
													    '''image_processor''': image_processor,
													}

													return components







						def 					__lowercase    (  self   :      Optional[int]				,    lowerCAmelCase__   :      Union[str, Any]				,    lowerCAmelCase__   :      str=0				):

													"""simple docstring"""
													if str(lowerCAmelCase__				).startswith('''mps'''				):
																				SCREAMING_SNAKE_CASE					:      List[str]     					=			torch.manual_seed(lowerCAmelCase__				)
													else:
																				SCREAMING_SNAKE_CASE					:      Tuple     					=			torch.Generator(device=lowerCAmelCase__				).manual_seed(lowerCAmelCase__				)
													SCREAMING_SNAKE_CASE					:      List[str]     					=			{
													    '''prompt''': '''horse''',
													    '''generator''': generator,
													    '''guidance_scale''': 4.0,
													    '''num_inference_steps''': 2,
													    '''output_type''': '''np''',
													}
													return inputs







						def 					__lowercase    (  self   :      List[Any]				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      List[Any]     					=			'''cpu'''

													SCREAMING_SNAKE_CASE					:      List[Any]     					=			self.get_dummy_components()

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

													pipe.set_progress_bar_config(disable=lowerCAmelCase__				)

													SCREAMING_SNAKE_CASE					:      Dict     					=			pipe(**self.get_dummy_inputs(lowerCAmelCase__				)				)
													SCREAMING_SNAKE_CASE					:      str     					=			output.image_embeds

													SCREAMING_SNAKE_CASE					:      Tuple     					=			pipe(
													    **self.get_dummy_inputs(lowerCAmelCase__				)				,    return_dict=lowerCAmelCase__				,    )[0]

													SCREAMING_SNAKE_CASE					:      List[Any]     					=			image[0, -10:]
													SCREAMING_SNAKE_CASE					:      List[str]     					=			image_from_tuple[0, -10:]

													assert image.shape == (1, 32)

													SCREAMING_SNAKE_CASE					:      List[str]     					=			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 					__lowercase    (  self   :      Tuple				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      int     					=			torch_device == '''cpu'''
													SCREAMING_SNAKE_CASE					:      Dict     					=			True
													SCREAMING_SNAKE_CASE					:      Optional[Any]     					=			False

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







						@skip_mps
						def 					__lowercase    (  self   :      Optional[Any]				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      Tuple     					=			torch_device == '''cpu'''
													SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			False

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









'''simple docstring'''



import json
import os
import shutil
import tempfile
import unittest

import numpy as np
import pytest

from transformers import BertTokenizer, BertTokenizerFast
from transformers.models.bert.tokenization_bert import VOCAB_FILES_NAMES
from transformers.testing_utils import require_vision
from transformers.utils import FEATURE_EXTRACTOR_NAME, is_vision_available


if is_vision_available():
							from PIL import Image

							from transformers import ChineseCLIPImageProcessor, ChineseCLIPProcessor
@require_vision
class 	lowerCamelCase_							(					unittest.TestCase			):







						def 					__lowercase    (  self   :      Optional[int]				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      Optional[Any]     					=			tempfile.mkdtemp()

													SCREAMING_SNAKE_CASE					:      int     					=			[
													    '''[UNK]''',
													    '''[CLS]''',
													    '''[SEP]''',
													    '''[PAD]''',
													    '''[MASK]''',
													    '''的''',
													    '''价''',
													    '''格''',
													    '''是''',
													    '''15''',
													    '''便''',
													    '''alex''',
													    '''##andra''',
													    '''，''',
													    '''。''',
													    '''-''',
													    '''t''',
													    '''shirt''',
													]
													SCREAMING_SNAKE_CASE					:      Optional[Any]     					=			os.path.join(self.tmpdirname				,    VOCAB_FILES_NAMES['''vocab_file''']				)
													with open(self.vocab_file				,    '''w'''				,    encoding='''utf-8'''				) as vocab_writer:
																				vocab_writer.write(''''''.join([x + '''\n''' for x in vocab_tokens]				)				)

													SCREAMING_SNAKE_CASE					:      Optional[Any]     					=			{
													    '''do_resize''': True,
													    '''size''': {'''height''': 2_24, '''width''': 2_24},
													    '''do_center_crop''': True,
													    '''crop_size''': {'''height''': 18, '''width''': 18},
													    '''do_normalize''': True,
													    '''image_mean''': [0.4814_5466, 0.457_8275, 0.4082_1073],
													    '''image_std''': [0.2686_2954, 0.2613_0258, 0.2757_7711],
													    '''do_convert_rgb''': True,
													}
													SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			os.path.join(self.tmpdirname				,    lowerCAmelCase__				)
													with open(self.image_processor_file				,    '''w'''				,    encoding='''utf-8'''				) as fp:
																				json.dump(lowerCAmelCase__				,    lowerCAmelCase__				)







						def 					__lowercase    (  self   :      str				,    **lowerCAmelCase__   :      int				):

													"""simple docstring"""
													return BertTokenizer.from_pretrained(self.tmpdirname				,    **lowerCAmelCase__				)







						def 					__lowercase    (  self   :      Any				,    **lowerCAmelCase__   :      Dict				):

													"""simple docstring"""
													return BertTokenizerFast.from_pretrained(self.tmpdirname				,    **lowerCAmelCase__				)







						def 					__lowercase    (  self   :      List[Any]				,    **lowerCAmelCase__   :      Dict				):

													"""simple docstring"""
													return ChineseCLIPImageProcessor.from_pretrained(self.tmpdirname				,    **lowerCAmelCase__				)







						def 					__lowercase    (  self   :      List[Any]				):

													"""simple docstring"""
													shutil.rmtree(self.tmpdirname				)







						def 					__lowercase    (  self   :      int				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      Dict     					=			[np.random.randint(2_55				,    size=(3, 30, 4_00)				,    dtype=np.uinta				)]

													SCREAMING_SNAKE_CASE					:      Optional[Any]     					=			[Image.fromarray(np.moveaxis(lowerCAmelCase__				,    0				,    -1				)				) for x in image_inputs]

													return image_inputs







						def 					__lowercase    (  self   :      int				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      Dict     					=			self.get_tokenizer()
													SCREAMING_SNAKE_CASE					:      str     					=			self.get_rust_tokenizer()
													SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			self.get_image_processor()

													SCREAMING_SNAKE_CASE					:      Dict     					=			ChineseCLIPProcessor(tokenizer=lowerCAmelCase__				,    image_processor=lowerCAmelCase__				)
													processor_slow.save_pretrained(self.tmpdirname				)
													SCREAMING_SNAKE_CASE					:      List[str]     					=			ChineseCLIPProcessor.from_pretrained(self.tmpdirname				,    use_fast=lowerCAmelCase__				)

													SCREAMING_SNAKE_CASE					:      int     					=			ChineseCLIPProcessor(tokenizer=lowerCAmelCase__				,    image_processor=lowerCAmelCase__				)
													processor_fast.save_pretrained(self.tmpdirname				)
													SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			ChineseCLIPProcessor.from_pretrained(self.tmpdirname				)

													self.assertEqual(processor_slow.tokenizer.get_vocab()				,    tokenizer_slow.get_vocab()				)
													self.assertEqual(processor_fast.tokenizer.get_vocab()				,    tokenizer_fast.get_vocab()				)
													self.assertEqual(tokenizer_slow.get_vocab()				,    tokenizer_fast.get_vocab()				)
													self.assertIsInstance(processor_slow.tokenizer				,    lowerCAmelCase__				)
													self.assertIsInstance(processor_fast.tokenizer				,    lowerCAmelCase__				)

													self.assertEqual(processor_slow.image_processor.to_json_string()				,    image_processor.to_json_string()				)
													self.assertEqual(processor_fast.image_processor.to_json_string()				,    image_processor.to_json_string()				)
													self.assertIsInstance(processor_slow.image_processor				,    lowerCAmelCase__				)
													self.assertIsInstance(processor_fast.image_processor				,    lowerCAmelCase__				)







						def 					__lowercase    (  self   :      Tuple				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      Optional[int]     					=			ChineseCLIPProcessor(tokenizer=self.get_tokenizer()				,    image_processor=self.get_image_processor()				)
													processor.save_pretrained(self.tmpdirname				)

													SCREAMING_SNAKE_CASE					:      Optional[Any]     					=			self.get_tokenizer(cls_token='''(CLS)'''				,    sep_token='''(SEP)'''				)
													SCREAMING_SNAKE_CASE					:      Optional[Any]     					=			self.get_image_processor(do_normalize=lowerCAmelCase__				)

													SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			ChineseCLIPProcessor.from_pretrained(
													    self.tmpdirname				,    cls_token='''(CLS)'''				,    sep_token='''(SEP)'''				,    do_normalize=lowerCAmelCase__				)

													self.assertEqual(processor.tokenizer.get_vocab()				,    tokenizer_add_kwargs.get_vocab()				)
													self.assertIsInstance(processor.tokenizer				,    lowerCAmelCase__				)

													self.assertEqual(processor.image_processor.to_json_string()				,    image_processor_add_kwargs.to_json_string()				)
													self.assertIsInstance(processor.image_processor				,    lowerCAmelCase__				)







						def 					__lowercase    (  self   :      Optional[Any]				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      Any     					=			self.get_image_processor()
													SCREAMING_SNAKE_CASE					:      str     					=			self.get_tokenizer()

													SCREAMING_SNAKE_CASE					:      Tuple     					=			ChineseCLIPProcessor(tokenizer=lowerCAmelCase__				,    image_processor=lowerCAmelCase__				)

													SCREAMING_SNAKE_CASE					:      Tuple     					=			self.prepare_image_inputs()

													SCREAMING_SNAKE_CASE					:      List[Any]     					=			image_processor(lowerCAmelCase__				,    return_tensors='''np'''				)
													SCREAMING_SNAKE_CASE					:      List[Any]     					=			processor(images=lowerCAmelCase__				,    return_tensors='''np'''				)

													for key in input_feat_extract.keys():
																				self.assertAlmostEqual(input_feat_extract[key].sum()				,    input_processor[key].sum()				,    delta=1e-2				)







						def 					__lowercase    (  self   :      Dict				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      Optional[Any]     					=			self.get_image_processor()
													SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			self.get_tokenizer()

													SCREAMING_SNAKE_CASE					:      Tuple     					=			ChineseCLIPProcessor(tokenizer=lowerCAmelCase__				,    image_processor=lowerCAmelCase__				)

													SCREAMING_SNAKE_CASE					:      int     					=			'''Alexandra，T-shirt的价格是15便士。'''

													SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			processor(text=lowerCAmelCase__				)

													SCREAMING_SNAKE_CASE					:      List[str]     					=			tokenizer(lowerCAmelCase__				)

													for key in encoded_tok.keys():
																				self.assertListEqual(encoded_tok[key]				,    encoded_processor[key]				)







						def 					__lowercase    (  self   :      Optional[int]				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      List[Any]     					=			self.get_image_processor()
													SCREAMING_SNAKE_CASE					:      List[Any]     					=			self.get_tokenizer()

													SCREAMING_SNAKE_CASE					:      Tuple     					=			ChineseCLIPProcessor(tokenizer=lowerCAmelCase__				,    image_processor=lowerCAmelCase__				)

													SCREAMING_SNAKE_CASE					:      str     					=			'''Alexandra，T-shirt的价格是15便士。'''
													SCREAMING_SNAKE_CASE					:      Tuple     					=			self.prepare_image_inputs()

													SCREAMING_SNAKE_CASE					:      List[str]     					=			processor(text=lowerCAmelCase__				,    images=lowerCAmelCase__				)

													self.assertListEqual(list(inputs.keys()				)				,    ['''input_ids''', '''token_type_ids''', '''attention_mask''', '''pixel_values''']				)

													# test if it raises when no input is passed
													with pytest.raises(lowerCAmelCase__				):
																				processor()







						def 					__lowercase    (  self   :      Dict				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      Tuple     					=			self.get_image_processor()
													SCREAMING_SNAKE_CASE					:      List[Any]     					=			self.get_tokenizer()

													SCREAMING_SNAKE_CASE					:      Tuple     					=			ChineseCLIPProcessor(tokenizer=lowerCAmelCase__				,    image_processor=lowerCAmelCase__				)

													SCREAMING_SNAKE_CASE					:      List[Any]     					=			[[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

													SCREAMING_SNAKE_CASE					:      Any     					=			processor.batch_decode(lowerCAmelCase__				)
													SCREAMING_SNAKE_CASE					:      Tuple     					=			tokenizer.batch_decode(lowerCAmelCase__				)

													self.assertListEqual(lowerCAmelCase__				,    lowerCAmelCase__				)







						def 					__lowercase    (  self   :      Dict				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      str     					=			self.get_image_processor()
													SCREAMING_SNAKE_CASE					:      List[str]     					=			self.get_tokenizer()

													SCREAMING_SNAKE_CASE					:      Dict     					=			ChineseCLIPProcessor(tokenizer=lowerCAmelCase__				,    image_processor=lowerCAmelCase__				)

													SCREAMING_SNAKE_CASE					:      int     					=			'''Alexandra，T-shirt的价格是15便士。'''
													SCREAMING_SNAKE_CASE					:      List[Any]     					=			self.prepare_image_inputs()

													SCREAMING_SNAKE_CASE					:      Any     					=			processor(text=lowerCAmelCase__				,    images=lowerCAmelCase__				)

													self.assertListEqual(list(inputs.keys()				)				,    processor.model_input_names				)




