





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

					@property
					def 	_UpperCamelCase     (      self      ):





												"""simple docstring"""

												return 32

					@property
					def 	_UpperCamelCase     (      self      ):





												"""simple docstring"""

												return 32

					@property
					def 	_UpperCamelCase     (      self      ):





												"""simple docstring"""

												return self.time_input_dim

					@property
					def 	_UpperCamelCase     (      self      ):





												"""simple docstring"""

												return self.time_input_dim * 4

					@property
					def 	_UpperCamelCase     (      self      ):





												"""simple docstring"""

												return 100

					@property
					def 	_UpperCamelCase     (      self      ):





												"""simple docstring"""

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

					@property
					def 	_UpperCamelCase     (      self      ):





												"""simple docstring"""

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





												"""simple docstring"""

												torch.manual_seed(0      )

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

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

					@property
					def 	_UpperCamelCase     (      self      ):





												"""simple docstring"""

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

												_UpperCamelCase              =						CLIPVisionModelWithProjection(A      )
												return model

					@property
					def 	_UpperCamelCase     (      self      ):





												"""simple docstring"""

												_UpperCamelCase              =						CLIPImageProcessor(
												    crop_size=224,       do_center_crop=A,       do_normalize=A,       do_resize=A,       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 	_UpperCamelCase     (      self      ):





												"""simple docstring"""

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

												_UpperCamelCase              =						UnCLIPScheduler(
												    variance_type='''fixed_small_log''',       prediction_type='''sample''',       num_train_timesteps=1000,       clip_sample=A,       clip_sample_range=10.0,       )

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

												return components

					def 	_UpperCamelCase     (      self,       A,       A=0      ):





												"""simple docstring"""

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

					def 	_UpperCamelCase     (      self      ):





												"""simple docstring"""

												_UpperCamelCase              =						'''cpu'''

												_UpperCamelCase              =						self.get_dummy_components()

												_UpperCamelCase              =						self.pipeline_class(**A      )
												_UpperCamelCase              =						pipe.to(A      )

												pipe.set_progress_bar_config(disable=A      )

												_UpperCamelCase              =						pipe(**self.get_dummy_inputs(A      )      )
												_UpperCamelCase              =						output.image_embeds

												_UpperCamelCase              =						pipe(
												    **self.get_dummy_inputs(A      ),       return_dict=A,       )[0]

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

												assert image.shape == (1, 32)

												_UpperCamelCase              =						np.array(
												    [-0.0_532, 1.7_120, 0.3_656, -1.0_852, -0.8_946, -1.1_756, 0.4_348, 0.2_482, 0.5_146, -0.1_156]      )

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





												"""simple docstring"""

												_UpperCamelCase              =						torch_device == '''cpu'''
												_UpperCamelCase              =						True
												_UpperCamelCase              =						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      ):





												"""simple docstring"""

												_UpperCamelCase              =						torch_device == '''cpu'''
												_UpperCamelCase              =						False

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













def     SCREAMING_SNAKE_CASE			(      lowerCAmelCase					):
       _UpperCamelCase              =						[]
       if len(lowerCAmelCase					) == 1:
              return [nums.copy()]
       for _ in range(len(lowerCAmelCase					)					):
              _UpperCamelCase              =						nums.pop(0					)
              _UpperCamelCase              =						permute(lowerCAmelCase					)
              for perm in permutations:
                     perm.append(lowerCAmelCase					)
              result.extend(lowerCAmelCase					)
              nums.append(lowerCAmelCase					)
       return result


def     SCREAMING_SNAKE_CASE			(      lowerCAmelCase					):

       def backtrack(lowerCAmelCase					):
              if start == len(lowerCAmelCase					) - 1:
                     output.append(nums[:]					)
              else:
                     for i in range(lowerCAmelCase    ,       len(lowerCAmelCase					)					):
                            _UpperCamelCase       ,		_UpperCamelCase              =						nums[i], nums[start]
                            backtrack(start + 1					)
                            _UpperCamelCase       ,		_UpperCamelCase              =						nums[i], nums[start]  # backtrack

       _UpperCamelCase              =						[]
       backtrack(0					)
       return output


if __name__ == "__main__":
       import doctest

       # use res to print the data in permute2 function
       lowercase    : Optional[Any]    	=  permutea([1, 2, 3])
       print(res)
       doctest.testmod()






