




'''simple docstring'''


import copy
import json
import os
import tempfile

from transformers import is_torch_available

from .test_configuration_utils import config_common_kwargs

class      A       (						_a       ):







							def __init__(    self			:    Union[str, Any]				,     lowerCAmelCase_			:    Tuple				,     lowerCAmelCase_			:    Tuple=None				,     lowerCAmelCase_			:    Tuple=True				,     lowerCAmelCase_			:    Union[str, Any]=None				,     **lowerCAmelCase_			:    Optional[int]   )     ->				Dict:


														"""simple docstring"""


														_a      	=							parent
														_a      	=							config_class
														_a      	=							has_text_modality
														_a      	=							kwargs
														_a      	=							common_properties







							def   __lowerCAmelCase     (    self			:    Union[str, Any]   )     ->				Optional[Any]:


														"""simple docstring"""


														_a      	=							self.config_class(**self.inputs_dict   )
														_a      	=							(
														    ['''hidden_size''', '''num_attention_heads''', '''num_hidden_layers''']
														    if self.common_properties is None
														    else self.common_properties
														)

														# Add common fields for text models
														if self.has_text_modality:
																					common_properties.extend(['''vocab_size''']   )

														# Test that config has the common properties as getters
														for prop in common_properties:
																					self.parent.assertTrue(hasattr(lowerCAmelCase_				,     lowerCAmelCase_   )				,     msg=F'`{prop}` does not exist'   )

														# Test that config has the common properties as setter
														for idx, name in enumerate(lowerCAmelCase_   ):
																					try:
																												setattr(lowerCAmelCase_				,     lowerCAmelCase_				,     lowerCAmelCase_   )
																												self.parent.assertEqual(
																												    getattr(lowerCAmelCase_				,     lowerCAmelCase_   )				,     lowerCAmelCase_				,     msg=F'`{name} value {idx} expected, but was {getattr(lowerCAmelCase_				,     lowerCAmelCase_   )}'   )
																					except NotImplementedError:
																												# Some models might not be able to implement setters for common_properties
																												# In that case, a NotImplementedError is raised
																												pass

        # Test if config class can be called with Config(prop_name=..)
														for idx, name in enumerate(lowerCAmelCase_   ):
																					try:
																												_a      	=							self.config_class(**{name: idx}   )
																												self.parent.assertEqual(
																												    getattr(lowerCAmelCase_				,     lowerCAmelCase_   )				,     lowerCAmelCase_				,     msg=F'`{name} value {idx} expected, but was {getattr(lowerCAmelCase_				,     lowerCAmelCase_   )}'   )
																					except NotImplementedError:
																												# Some models might not be able to implement setters for common_properties
																												# In that case, a NotImplementedError is raised
																												pass







							def   __lowerCAmelCase     (    self			:    Optional[Any]   )     ->				Optional[Any]:


														"""simple docstring"""


														_a      	=							self.config_class(**self.inputs_dict   )
														_a      	=							json.loads(config.to_json_string()   )
														for key, value in self.inputs_dict.items():
																					self.parent.assertEqual(obj[key]				,     lowerCAmelCase_   )







							def   __lowerCAmelCase     (    self			:    List[Any]   )     ->				Optional[Any]:


														"""simple docstring"""


														_a      	=							self.config_class(**self.inputs_dict   )

														with tempfile.TemporaryDirectory() as tmpdirname:
																					_a      	=							os.path.join(lowerCAmelCase_				,     '''config.json'''   )
																					config_first.to_json_file(lowerCAmelCase_   )
																					_a      	=							self.config_class.from_json_file(lowerCAmelCase_   )

														self.parent.assertEqual(config_second.to_dict()				,     config_first.to_dict()   )







							def   __lowerCAmelCase     (    self			:    List[Any]   )     ->				Any:


														"""simple docstring"""


														_a      	=							self.config_class(**self.inputs_dict   )

														with tempfile.TemporaryDirectory() as tmpdirname:
																					config_first.save_pretrained(lowerCAmelCase_   )
																					_a      	=							self.config_class.from_pretrained(lowerCAmelCase_   )

														self.parent.assertEqual(config_second.to_dict()				,     config_first.to_dict()   )







							def   __lowerCAmelCase     (    self			:    Tuple   )     ->				int:


														"""simple docstring"""


														_a      	=							self.config_class(**self.inputs_dict   )

														_a      	=							'''test'''
														with tempfile.TemporaryDirectory() as tmpdirname:
																					_a      	=							os.path.join(lowerCAmelCase_				,     lowerCAmelCase_   )
																					config_first.save_pretrained(lowerCAmelCase_   )
																					_a      	=							self.config_class.from_pretrained(lowerCAmelCase_				,     subfolder=lowerCAmelCase_   )

														self.parent.assertEqual(config_second.to_dict()				,     config_first.to_dict()   )







							def   __lowerCAmelCase     (    self			:    Optional[Any]   )     ->				Tuple:


														"""simple docstring"""


														_a      	=							self.config_class(**self.inputs_dict				,     num_labels=5   )
														self.parent.assertEqual(len(config.idalabel   )				,     5   )
														self.parent.assertEqual(len(config.labelaid   )				,     5   )

														_a      	=							3
														self.parent.assertEqual(len(config.idalabel   )				,     3   )
														self.parent.assertEqual(len(config.labelaid   )				,     3   )







							def   __lowerCAmelCase     (    self			:    Optional[Any]   )     ->				str:


														"""simple docstring"""


														if self.config_class.is_composition:
																					return
														_a      	=							self.config_class()
														self.parent.assertIsNotNone(lowerCAmelCase_   )







							def   __lowerCAmelCase     (    self			:    List[Any]   )     ->				Tuple:


														"""simple docstring"""


														_a      	=							copy.deepcopy(lowerCAmelCase_   )
														_a      	=							self.config_class(**lowerCAmelCase_   )
														_a      	=							[]
														for key, value in config_common_kwargs.items():
																					if key == "torch_dtype":
																												if not is_torch_available():
																																			continue
																												else:
																																			import torch

																																			if config.torch_dtype != torch.floataa:
																																										wrong_values.append(('''torch_dtype''', config.torch_dtype, torch.floataa)   )
																					elif getattr(lowerCAmelCase_				,     lowerCAmelCase_   ) != value:
																												wrong_values.append((key, getattr(lowerCAmelCase_				,     lowerCAmelCase_   ), value)   )

														if len(lowerCAmelCase_   ) > 0:
																					_a      	=							'''\n'''.join([F'- {v[0]}: got {v[1]} instead of {v[2]}' for v in wrong_values]   )
																					raise ValueError(F'The following keys were not properly set in the config:\n{errors}'   )







							def   __lowerCAmelCase     (    self			:    int   )     ->				Union[str, Any]:


														"""simple docstring"""


														self.create_and_test_config_common_properties()
														self.create_and_test_config_to_json_string()
														self.create_and_test_config_to_json_file()
														self.create_and_test_config_from_and_save_pretrained()
														self.create_and_test_config_from_and_save_pretrained_subfolder()
														self.create_and_test_config_with_num_labels()
														self.check_config_can_be_init_without_params()
														self.check_config_arguments_init()


import gc
import unittest

import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTextModelWithProjection, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    DDPMScheduler,
    PriorTransformer,
    StableUnCLIPPipeline,
    UNetaDConditionModel,
)
from diffusers.pipelines.stable_diffusion.stable_unclip_image_normalizer import StableUnCLIPImageNormalizer
from diffusers.utils.testing_utils import enable_full_determinism, load_numpy, require_torch_gpu, slow, torch_device

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import (
    PipelineKarrasSchedulerTesterMixin,
    PipelineLatentTesterMixin,
    PipelineTesterMixin,
    assert_mean_pixel_difference,
)


enable_full_determinism()
class     lowerCAmelCase_     (       __lowercase,  __lowercase,  __lowercase,  unittest.TestCase ):
							UpperCAmelCase				   =     StableUnCLIPPipeline
							UpperCAmelCase				   =     TEXT_TO_IMAGE_PARAMS
							UpperCAmelCase				   =     TEXT_TO_IMAGE_BATCH_PARAMS
							UpperCAmelCase				   =     TEXT_TO_IMAGE_IMAGE_PARAMS
							UpperCAmelCase				   =     TEXT_TO_IMAGE_IMAGE_PARAMS

							# TODO(will) Expected attn_bias.stride(1) == 0 to be true, but got false
							UpperCAmelCase				   =     False







							def  UpperCamelCase_						(   self      :     Optional[int]		):
												_UpperCamelCase			     =     32
												_UpperCamelCase			     =     embedder_hidden_size

												# prior components

												torch.manual_seed(0		)
												_UpperCamelCase			     =     CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''		)

												torch.manual_seed(0		)
												_UpperCamelCase			     =     CLIPTextModelWithProjection(
												    CLIPTextConfig(
												        bos_token_id=0 ,			eos_token_id=2 ,			hidden_size=_A ,			projection_dim=_A ,			intermediate_size=37 ,			layer_norm_eps=1e-05 ,			num_attention_heads=4 ,			num_hidden_layers=5 ,			pad_token_id=1 ,			vocab_size=1000 ,			)		)

												torch.manual_seed(0		)
												_UpperCamelCase			     =     PriorTransformer(
												    num_attention_heads=2 ,			attention_head_dim=12 ,			embedding_dim=_A ,			num_layers=1 ,			)

												torch.manual_seed(0		)
												_UpperCamelCase			     =     DDPMScheduler(
												    variance_type='''fixed_small_log''' ,			prediction_type='''sample''' ,			num_train_timesteps=1000 ,			clip_sample=_A ,			clip_sample_range=5.0 ,			beta_schedule='''squaredcos_cap_v2''' ,			)

												# regular denoising components

												torch.manual_seed(0		)
												_UpperCamelCase			     =     StableUnCLIPImageNormalizer(embedding_dim=_A		)
												_UpperCamelCase			     =     DDPMScheduler(beta_schedule='''squaredcos_cap_v2'''		)

												torch.manual_seed(0		)
												_UpperCamelCase			     =     CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''		)

												torch.manual_seed(0		)
												_UpperCamelCase			     =     CLIPTextModel(
												    CLIPTextConfig(
												        bos_token_id=0 ,			eos_token_id=2 ,			hidden_size=_A ,			projection_dim=32 ,			intermediate_size=37 ,			layer_norm_eps=1e-05 ,			num_attention_heads=4 ,			num_hidden_layers=5 ,			pad_token_id=1 ,			vocab_size=1000 ,			)		)

												torch.manual_seed(0		)
												_UpperCamelCase			     =     UNetaDConditionModel(
												    sample_size=32 ,			in_channels=4 ,			out_channels=4 ,			down_block_types=('''CrossAttnDownBlock2D''', '''DownBlock2D''') ,			up_block_types=('''UpBlock2D''', '''CrossAttnUpBlock2D''') ,			block_out_channels=(32, 64) ,			attention_head_dim=(2, 4) ,			class_embed_type='''projection''' ,			projection_class_embeddings_input_dim=embedder_projection_dim * 2 ,			cross_attention_dim=_A ,			layers_per_block=1 ,			upcast_attention=_A ,			use_linear_projection=_A ,			)

												torch.manual_seed(0		)
												_UpperCamelCase			     =     DDIMScheduler(
												    beta_schedule='''scaled_linear''' ,			beta_start=0.0_0085 ,			beta_end=0.012 ,			prediction_type='''v_prediction''' ,			set_alpha_to_one=_A ,			steps_offset=1 ,			)

												torch.manual_seed(0		)
												_UpperCamelCase			     =     AutoencoderKL()

												_UpperCamelCase			     =     {
												    # prior components
												    '''prior_tokenizer''': prior_tokenizer,
												    '''prior_text_encoder''': prior_text_encoder,
												    '''prior''': prior,
												    '''prior_scheduler''': prior_scheduler,
												    # image noising components
												    '''image_normalizer''': image_normalizer,
												    '''image_noising_scheduler''': image_noising_scheduler,
												    # regular denoising components
												    '''tokenizer''': tokenizer,
												    '''text_encoder''': text_encoder,
												    '''unet''': unet,
												    '''scheduler''': scheduler,
												    '''vae''': vae,
												}

												return components







							def  UpperCamelCase_						(   self      :     Dict ,			_A      :     Tuple ,			_A      :     Dict=0		):
												if str(_A		).startswith('''mps'''		):
																	_UpperCamelCase			     =     torch.manual_seed(_A		)
												else:
																	_UpperCamelCase			     =     torch.Generator(device=_A		).manual_seed(_A		)
												_UpperCamelCase			     =     {
												    '''prompt''': '''A painting of a squirrel eating a burger''',
												    '''generator''': generator,
												    '''num_inference_steps''': 2,
												    '''prior_num_inference_steps''': 2,
												    '''output_type''': '''numpy''',
												}
												return inputs







							def  UpperCamelCase_						(   self      :     Dict		):
												_UpperCamelCase			     =     torch_device == '''cpu'''

												self._test_attention_slicing_forward_pass(test_max_difference=_A		)







							def  UpperCamelCase_						(   self      :     List[Any]		):
												_UpperCamelCase			     =     torch_device in ['''cpu''', '''mps''']

												self._test_inference_batch_single_identical(test_max_difference=_A		)




@slow
@require_torch_gpu
class     lowerCAmelCase_     (       unittest.TestCase ):







							def  UpperCamelCase_						(   self      :     Optional[Any]		):
												# clean up the VRAM after each test
												super().tearDown()
												gc.collect()
												torch.cuda.empty_cache()







							def  UpperCamelCase_						(   self      :     List[str]		):
												_UpperCamelCase			     =     load_numpy(
												    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/stable_unclip_2_1_l_anime_turtle_fp16.npy'''		)

												_UpperCamelCase			     =     StableUnCLIPPipeline.from_pretrained('''fusing/stable-unclip-2-1-l''' ,			torch_dtype=torch.floataa		)
												pipe.to(_A		)
												pipe.set_progress_bar_config(disable=_A		)
												# stable unclip will oom when integration tests are run on a V100,
												# so turn on memory savings
												pipe.enable_attention_slicing()
												pipe.enable_sequential_cpu_offload()

												_UpperCamelCase			     =     torch.Generator(device='''cpu'''		).manual_seed(0		)
												_UpperCamelCase			     =     pipe('''anime turle''' ,			generator=_A ,			output_type='''np'''		)

												_UpperCamelCase			     =     output.images[0]

												assert image.shape == (768, 768, 3)

												assert_mean_pixel_difference(_A ,			_A		)







							def  UpperCamelCase_						(   self      :     Optional[Any]		):
												torch.cuda.empty_cache()
												torch.cuda.reset_max_memory_allocated()
												torch.cuda.reset_peak_memory_stats()

												_UpperCamelCase			     =     StableUnCLIPPipeline.from_pretrained('''fusing/stable-unclip-2-1-l''' ,			torch_dtype=torch.floataa		)
												_UpperCamelCase			     =     pipe.to(_A		)
												pipe.set_progress_bar_config(disable=_A		)
												pipe.enable_attention_slicing()
												pipe.enable_sequential_cpu_offload()

												_UpperCamelCase			     =     pipe(
												    '''anime turtle''' ,			prior_num_inference_steps=2 ,			num_inference_steps=2 ,			output_type='''np''' ,			)

												_UpperCamelCase			     =     torch.cuda.max_memory_allocated()
												# make sure that less than 7 GB is allocated
												assert mem_bytes < 7 * 10**9
