'''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     a__( lowerCAmelCase__			,						unittest.TestCase     ):


			'''simple docstring'''






			UpperCAmelCase_      :					int								=	KandinskyPriorPipeline
			UpperCAmelCase_      :					Optional[int]								=	['''prompt''']
			UpperCAmelCase_      :					Optional[Any]								=	['''prompt''', '''negative_prompt''']
			UpperCAmelCase_      :					List[Any]								=	[
			    '''num_images_per_prompt''',
			    '''generator''',
			    '''num_inference_steps''',
			    '''latents''',
			    '''negative_prompt''',
			    '''guidance_scale''',
			    '''output_type''',
			    '''return_dict''',
			]
			UpperCAmelCase_      :					List[str]								=	False



			@property
			def 							a_	(       self):




					"""simple docstring"""


					return 32



			@property
			def 							a_	(       self):




					"""simple docstring"""


					return 32



			@property
			def 							a_	(       self):




					"""simple docstring"""


					return self.time_input_dim



			@property
			def 							a_	(       self):




					"""simple docstring"""


					return self.time_input_dim * 4



			@property
			def 							a_	(       self):




					"""simple docstring"""


					return 100



			@property
			def 							a_	(       self):




					"""simple docstring"""


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



			@property
			def 							a_	(       self):




					"""simple docstring"""


					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(__lowerCAmelCase)



			@property
			def 							a_	(       self):




					"""simple docstring"""


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



			@property
			def 							a_	(       self):




					"""simple docstring"""


					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(__lowerCAmelCase)
					return model



			@property
			def 							a_	(       self):




					"""simple docstring"""


					lowerCAmelCase        =  CLIPImageProcessor(
					    crop_size=224	,   do_center_crop=__lowerCAmelCase	,   do_normalize=__lowerCAmelCase	,   do_resize=__lowerCAmelCase	,   image_mean=[0.48145466, 0.4578275, 0.40821073]	,   image_std=[0.26862954, 0.26130258, 0.27577711]	,   resample=3	,   size=224	,   )

					return image_processor



			def 							a_	(       self):




					"""simple docstring"""


					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=__lowerCAmelCase	,   clip_sample_range=10.0	,   )

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

					return components



			def 							a_	(       self	,   __lowerCAmelCase	,   __lowerCAmelCase=0):




					"""simple docstring"""


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



			def 							a_	(       self):




					"""simple docstring"""


					lowerCAmelCase        =  """cpu"""

					lowerCAmelCase        =  self.get_dummy_components()

					lowerCAmelCase        =  self.pipeline_class(**__lowerCAmelCase)
					lowerCAmelCase        =  pipe.to(__lowerCAmelCase)

					pipe.set_progress_bar_config(disable=__lowerCAmelCase)

					lowerCAmelCase        =  pipe(**self.get_dummy_inputs(__lowerCAmelCase))
					lowerCAmelCase        =  output.image_embeds

					lowerCAmelCase        =  pipe(
					    **self.get_dummy_inputs(__lowerCAmelCase)	,   return_dict=__lowerCAmelCase	,   )[0]

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

					assert image.shape == (1, 32)

					lowerCAmelCase        =  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 							a_	(       self):




					"""simple docstring"""


					lowerCAmelCase        =  torch_device == """cpu"""
					lowerCAmelCase        =  True
					lowerCAmelCase        =  False

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







			@skip_mps
			def 							a_	(       self):




					"""simple docstring"""


					lowerCAmelCase        =  torch_device == """cpu"""
					lowerCAmelCase        =  False

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





'''simple docstring'''




from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


__lowercase				   =  {
    '''configuration_bart''': ['''BART_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''BartConfig''', '''BartOnnxConfig'''],
    '''tokenization_bart''': ['''BartTokenizer'''],
}

try:
						if not is_tokenizers_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						__lowercase				   =  ['''BartTokenizerFast''']

try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						__lowercase				   =  [
						    '''BART_PRETRAINED_MODEL_ARCHIVE_LIST''',
						    '''BartForCausalLM''',
						    '''BartForConditionalGeneration''',
						    '''BartForQuestionAnswering''',
						    '''BartForSequenceClassification''',
						    '''BartModel''',
						    '''BartPretrainedModel''',
						    '''PretrainedBartModel''',
						]

try:
						if not is_tf_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						__lowercase				   =  [
						    '''TFBartForConditionalGeneration''',
						    '''TFBartForSequenceClassification''',
						    '''TFBartModel''',
						    '''TFBartPretrainedModel''',
						]

try:
						if not is_flax_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						__lowercase				   =  [
						    '''FlaxBartDecoderPreTrainedModel''',
						    '''FlaxBartForCausalLM''',
						    '''FlaxBartForConditionalGeneration''',
						    '''FlaxBartForQuestionAnswering''',
						    '''FlaxBartForSequenceClassification''',
						    '''FlaxBartModel''',
						    '''FlaxBartPreTrainedModel''',
						]

if TYPE_CHECKING:
						from .configuration_bart import BART_PRETRAINED_CONFIG_ARCHIVE_MAP, BartConfig, BartOnnxConfig
						from .tokenization_bart import BartTokenizer

						try:
												if not is_tokenizers_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .tokenization_bart_fast import BartTokenizerFast

						try:
												if not is_torch_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_bart import (
												    BART_PRETRAINED_MODEL_ARCHIVE_LIST,
												    BartForCausalLM,
												    BartForConditionalGeneration,
												    BartForQuestionAnswering,
												    BartForSequenceClassification,
												    BartModel,
												    BartPretrainedModel,
												    PretrainedBartModel,
												)

						try:
												if not is_tf_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_tf_bart import (
												    TFBartForConditionalGeneration,
												    TFBartForSequenceClassification,
												    TFBartModel,
												    TFBartPretrainedModel,
												)

						try:
												if not is_flax_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_flax_bart import (
												    FlaxBartDecoderPreTrainedModel,
												    FlaxBartForCausalLM,
												    FlaxBartForConditionalGeneration,
												    FlaxBartForQuestionAnswering,
												    FlaxBartForSequenceClassification,
												    FlaxBartModel,
												    FlaxBartPreTrainedModel,
												)

else:
						import sys

						__lowercase				   =  _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)




