






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


							@property
							def 						_UpperCamelCase       (			self      :						Union[str, Any]							):
													'''simple docstring'''





													return 32


							@property
							def 						_UpperCamelCase       (			self      :						Dict							):
													'''simple docstring'''





													return 32


							@property
							def 						_UpperCamelCase       (			self      :						Optional[int]							):
													'''simple docstring'''





													return self.time_input_dim


							@property
							def 						_UpperCamelCase       (			self      :						Union[str, Any]							):
													'''simple docstring'''





													return self.time_input_dim * 4


							@property
							def 						_UpperCamelCase       (			self      :						Tuple							):
													'''simple docstring'''





													return 100


							@property
							def 						_UpperCamelCase       (			self      :						int							):
													'''simple docstring'''





													A__						:  Union[str, Any]		  =  CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""							)
													return tokenizer


							@property
							def 						_UpperCamelCase       (			self      :						List[str]							):
													'''simple docstring'''





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


							@property
							def 						_UpperCamelCase       (			self      :						Dict							):
													'''simple docstring'''





													torch.manual_seed(0							)

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

													A__						:  str		  =  PriorTransformer(**lowercase__							)
													# 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
													A__						:  int		  =  nn.Parameter(torch.ones(model.clip_std.shape							)							)
													return model


							@property
							def 						_UpperCamelCase       (			self      :						Union[str, Any]							):
													'''simple docstring'''





													torch.manual_seed(0							)
													A__						:  List[str]		  =  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			,    )

													A__						:  List[str]		  =  CLIPVisionModelWithProjection(lowercase__							)
													return model


							@property
							def 						_UpperCamelCase       (			self      :						Dict							):
													'''simple docstring'''





													A__						:  int		  =  CLIPImageProcessor(
													    crop_size=224			,    do_center_crop=lowercase__			,    do_normalize=lowercase__			,    do_resize=lowercase__			,    image_mean=[0.48145466, 0.4578275, 0.40821073]			,    image_std=[0.26862954, 0.26130258, 0.27577711]			,    resample=3			,    size=224			,    )

													return image_processor


							def 						_UpperCamelCase       (			self      :						List[Any]							):
													'''simple docstring'''





													A__						:  Optional[int]		  =  self.dummy_prior
													A__						:  Dict		  =  self.dummy_image_encoder
													A__						:  List[str]		  =  self.dummy_text_encoder
													A__						:  Dict		  =  self.dummy_tokenizer
													A__						:  Dict		  =  self.dummy_image_processor

													A__						:  str		  =  UnCLIPScheduler(
													    variance_type="""fixed_small_log"""			,    prediction_type="""sample"""			,    num_train_timesteps=1000			,    clip_sample=lowercase__			,    clip_sample_range=10.0			,    )

													A__						:  Union[str, Any]		  =  {
													    '''prior''': prior,
													    '''image_encoder''': image_encoder,
													    '''text_encoder''': text_encoder,
													    '''tokenizer''': tokenizer,
													    '''scheduler''': scheduler,
													    '''image_processor''': image_processor,
													}

													return components


							def 						_UpperCamelCase       (			self      :						List[str]			,    snake_case      :						Tuple			,    snake_case      :						Optional[Any]=0							):
													'''simple docstring'''





													if str(lowercase__							).startswith("""mps"""							):
																			A__						:  List[str]		  =  torch.manual_seed(lowercase__							)
													else:
																			A__						:  Dict		  =  torch.Generator(device=lowercase__							).manual_seed(lowercase__							)
													A__						:  Any		  =  {
													    '''prompt''': '''horse''',
													    '''generator''': generator,
													    '''guidance_scale''': 4.0,
													    '''num_inference_steps''': 2,
													    '''output_type''': '''np''',
													}
													return inputs


							def 						_UpperCamelCase       (			self      :						int							):
													'''simple docstring'''





													A__						:  Optional[int]		  =  '''cpu'''

													A__						:  Dict		  =  self.get_dummy_components()

													A__						:  Dict		  =  self.pipeline_class(**lowercase__							)
													A__						:  Tuple		  =  pipe.to(lowercase__							)

													pipe.set_progress_bar_config(disable=lowercase__							)

													A__						:  Tuple		  =  pipe(**self.get_dummy_inputs(lowercase__							)							)
													A__						:  Any		  =  output.image_embeds

													A__						:  Union[str, Any]		  =  pipe(
													    **self.get_dummy_inputs(lowercase__							)			,    return_dict=lowercase__			,    )[0]

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

													assert image.shape == (1, 32)

													A__						:  List[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 						_UpperCamelCase       (			self      :						Optional[int]							):
													'''simple docstring'''





													A__						:  int		  =  torch_device == '''cpu'''
													A__						:  List[str]		  =  True
													A__						:  List[str]		  =  False

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


							@skip_mps
							def 						_UpperCamelCase       (			self      :						Any							):
													'''simple docstring'''





													A__						:  int		  =  torch_device == '''cpu'''
													A__						:  List[str]		  =  False

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














"""simple docstring"""



import os

try:
						from .build_directory_md import good_file_paths
except ImportError:
						from build_directory_md import good_file_paths  # type: ignore

A_    =							list(good_file_paths())
assert filepaths, "good_file_paths() failed!"

A_    =							[file for file in filepaths if file != file.lower()]
if upper_files:
						print(F'{len(upper_files)} files contain uppercase characters:')
						print('''\n'''.join(upper_files) + '''\n''')

A_    =							[file for file in filepaths if ''' ''' in file]
if space_files:
						print(F'{len(space_files)} files contain space characters:')
						print('''\n'''.join(space_files) + '''\n''')

A_    =							[file for file in filepaths if '''-''' in file]
if hyphen_files:
						print(F'{len(hyphen_files)} files contain hyphen characters:')
						print('''\n'''.join(hyphen_files) + '''\n''')

A_    =							[file for file in filepaths if os.sep not in file]
if nodir_files:
						print(F'{len(nodir_files)} files are not in a directory:')
						print('''\n'''.join(nodir_files) + '''\n''')

A_    =							len(upper_files + space_files + hyphen_files + nodir_files)
if bad_files:
						import sys

						sys.exit(bad_files)






