





import gc
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModelWithProjection, CLIPTokenizer

from diffusers import HeunDiscreteScheduler, PriorTransformer, ShapEPipeline
from diffusers.pipelines.shap_e import ShapERenderer
from diffusers.utils import load_numpy, slow
from diffusers.utils.testing_utils import require_torch_gpu, torch_device

from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference





class 				a			(      __lowercase   ,unittest.TestCase			):
				SCREAMING_SNAKE_CASE__     :   Dict		      =     ShapEPipeline
				SCREAMING_SNAKE_CASE__     :   Union[str, Any]		      =     ['''prompt''']
				SCREAMING_SNAKE_CASE__     :   Optional[int]		      =     ['''prompt''']
				SCREAMING_SNAKE_CASE__     :   Union[str, Any]		      =     [
				    '''num_images_per_prompt''',
				    '''num_inference_steps''',
				    '''generator''',
				    '''latents''',
				    '''guidance_scale''',
				    '''frame_size''',
				    '''output_type''',
				    '''return_dict''',
				]
				SCREAMING_SNAKE_CASE__     :   Union[str, Any]		      =     False






				@property
				def 			snake_case_    (  self					):

										"""simple docstring"""




										return 32






				@property
				def 			snake_case_    (  self					):

										"""simple docstring"""




										return 32






				@property
				def 			snake_case_    (  self					):

										"""simple docstring"""




										return self.time_input_dim * 4






				@property
				def 			snake_case_    (  self					):

										"""simple docstring"""




										return 8






				@property
				def 			snake_case_    (  self					):

										"""simple docstring"""




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






				@property
				def 			snake_case_    (  self					):

										"""simple docstring"""




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






				@property
				def 			snake_case_    (  self					):

										"""simple docstring"""




										torch.manual_seed(0					)

										__SCREAMING_SNAKE_CASE:				int           =   {
										    '''num_attention_heads''': 2,
										    '''attention_head_dim''': 16,
										    '''embedding_dim''': self.time_input_dim,
										    '''num_embeddings''': 32,
										    '''embedding_proj_dim''': self.text_embedder_hidden_size,
										    '''time_embed_dim''': self.time_embed_dim,
										    '''num_layers''': 1,
										    '''clip_embed_dim''': self.time_input_dim * 2,
										    '''additional_embeddings''': 0,
										    '''time_embed_act_fn''': '''gelu''',
										    '''norm_in_type''': '''layer''',
										    '''encoder_hid_proj_type''': None,
										    '''added_emb_type''': None,
										}

										__SCREAMING_SNAKE_CASE:				List[str]           =   PriorTransformer(**_lowerCAmelCase					)
										return model






				@property
				def 			snake_case_    (  self					):

										"""simple docstring"""




										torch.manual_seed(0					)

										__SCREAMING_SNAKE_CASE:				str           =   {
										    '''param_shapes''': (
										        (self.renderer_dim, 93),
										        (self.renderer_dim, 8),
										        (self.renderer_dim, 8),
										        (self.renderer_dim, 8),
										    ),
										    '''d_latent''': self.time_input_dim,
										    '''d_hidden''': self.renderer_dim,
										    '''n_output''': 12,
										    '''background''': (
										        0.1,
										        0.1,
										        0.1,
										    ),
										}
										__SCREAMING_SNAKE_CASE:				Tuple           =   ShapERenderer(**_lowerCAmelCase					)
										return model






				def 			snake_case_    (  self					):

										"""simple docstring"""




										__SCREAMING_SNAKE_CASE:				Any           =   self.dummy_prior
										__SCREAMING_SNAKE_CASE:				Tuple           =   self.dummy_text_encoder
										__SCREAMING_SNAKE_CASE:				Any           =   self.dummy_tokenizer
										__SCREAMING_SNAKE_CASE:				Any           =   self.dummy_renderer

										__SCREAMING_SNAKE_CASE:				Union[str, Any]           =   HeunDiscreteScheduler(
										    beta_schedule='''exp'''			, num_train_timesteps=1024			, prediction_type='''sample'''			, use_karras_sigmas=_lowerCAmelCase			, clip_sample=_lowerCAmelCase			, clip_sample_range=1.0			, )
										__SCREAMING_SNAKE_CASE:				Optional[Any]           =   {
										    '''prior''': prior,
										    '''text_encoder''': text_encoder,
										    '''tokenizer''': tokenizer,
										    '''renderer''': renderer,
										    '''scheduler''': scheduler,
										}

										return components






				def 			snake_case_    (  self			, _lowerCAmelCase			, _lowerCAmelCase=0					):

										"""simple docstring"""




										if str(_lowerCAmelCase					).startswith('''mps'''					):
																__SCREAMING_SNAKE_CASE:				int           =   torch.manual_seed(_lowerCAmelCase					)
										else:
																__SCREAMING_SNAKE_CASE:				int           =   torch.Generator(device=_lowerCAmelCase					).manual_seed(_lowerCAmelCase					)
										__SCREAMING_SNAKE_CASE:				List[str]           =   {
										    '''prompt''': '''horse''',
										    '''generator''': generator,
										    '''num_inference_steps''': 1,
										    '''frame_size''': 32,
										    '''output_type''': '''np''',
										}
										return inputs






				def 			snake_case_    (  self					):

										"""simple docstring"""




										__SCREAMING_SNAKE_CASE:				Dict           =   '''cpu'''

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

										__SCREAMING_SNAKE_CASE:				Union[str, Any]           =   self.pipeline_class(**_lowerCAmelCase					)
										__SCREAMING_SNAKE_CASE:				Union[str, Any]           =   pipe.to(_lowerCAmelCase					)

										pipe.set_progress_bar_config(disable=_lowerCAmelCase					)

										__SCREAMING_SNAKE_CASE:				List[str]           =   pipe(**self.get_dummy_inputs(_lowerCAmelCase					)					)
										__SCREAMING_SNAKE_CASE:				int           =   output.images[0]
										__SCREAMING_SNAKE_CASE:				Dict           =   image[0, -3:, -3:, -1]

										assert image.shape == (20, 32, 32, 3)

										__SCREAMING_SNAKE_CASE:				str           =   np.array(
										    [
										        0.00039216,
										        0.00039216,
										        0.00039216,
										        0.00039216,
										        0.00039216,
										        0.00039216,
										        0.00039216,
										        0.00039216,
										        0.00039216,
										    ]					)

										assert np.abs(image_slice.flatten() - expected_slice					).max() < 1e-2






				def 			snake_case_    (  self					):

										"""simple docstring"""




										self._test_inference_batch_consistent(batch_sizes=[1, 2]					)






				def 			snake_case_    (  self					):

										"""simple docstring"""




										__SCREAMING_SNAKE_CASE:				Union[str, Any]           =   torch_device == '''cpu'''
										__SCREAMING_SNAKE_CASE:				Union[str, Any]           =   True

										self._test_inference_batch_single_identical(
										    batch_size=2			, test_max_difference=_lowerCAmelCase			, relax_max_difference=_lowerCAmelCase			, )






				def 			snake_case_    (  self					):

										"""simple docstring"""




										__SCREAMING_SNAKE_CASE:				Optional[Any]           =   self.get_dummy_components()
										__SCREAMING_SNAKE_CASE:				List[str]           =   self.pipeline_class(**_lowerCAmelCase					)
										__SCREAMING_SNAKE_CASE:				List[Any]           =   pipe.to(_lowerCAmelCase					)
										pipe.set_progress_bar_config(disable=_lowerCAmelCase					)

										__SCREAMING_SNAKE_CASE:				str           =   1
										__SCREAMING_SNAKE_CASE:				Optional[int]           =   2

										__SCREAMING_SNAKE_CASE:				Optional[int]           =   self.get_dummy_inputs(_lowerCAmelCase					)

										for key in inputs.keys():
																if key in self.batch_params:
																						__SCREAMING_SNAKE_CASE:				List[Any]           =   batch_size * [inputs[key]]

										__SCREAMING_SNAKE_CASE:				Union[str, Any]           =   pipe(**_lowerCAmelCase			, num_images_per_prompt=_lowerCAmelCase					)[0]

										assert images.shape[0] == batch_size * num_images_per_prompt





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






				def 			snake_case_    (  self					):

										"""simple docstring"""




										super().tearDown()
										gc.collect()
										torch.cuda.empty_cache()






				def 			snake_case_    (  self					):

										"""simple docstring"""




										__SCREAMING_SNAKE_CASE:				Optional[Any]           =   load_numpy(
										    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
										    '''/shap_e/test_shap_e_np_out.npy'''					)
										__SCREAMING_SNAKE_CASE:				List[Any]           =   ShapEPipeline.from_pretrained('''openai/shap-e'''					)
										__SCREAMING_SNAKE_CASE:				List[str]           =   pipe.to(_lowerCAmelCase					)
										pipe.set_progress_bar_config(disable=_lowerCAmelCase					)

										__SCREAMING_SNAKE_CASE:				List[Any]           =   torch.Generator(device=_lowerCAmelCase					).manual_seed(0					)

										__SCREAMING_SNAKE_CASE:				Optional[int]           =   pipe(
										    '''a shark'''			, generator=_lowerCAmelCase			, guidance_scale=15.0			, num_inference_steps=64			, frame_size=64			, output_type='''np'''			, ).images[0]

										assert images.shape == (20, 64, 64, 3)

										assert_mean_pixel_difference(_lowerCAmelCase			, _lowerCAmelCase					)










from ..utils import DummyObject, requires_backends





class 				a			(      metaclass=__lowercase			):
				SCREAMING_SNAKE_CASE__     :   List[Any]		      =     ['''torch''', '''scipy''']






				def __init__(  self			, *_lowerCAmelCase			, **_lowerCAmelCase					):

										"""simple docstring"""




										requires_backends(self			, ['''torch''', '''scipy''']					)






				@classmethod
				def 			snake_case_    (  cls			, *_lowerCAmelCase			, **_lowerCAmelCase					):

										"""simple docstring"""




										requires_backends(cls			, ['''torch''', '''scipy''']					)






				@classmethod
				def 			snake_case_    (  cls			, *_lowerCAmelCase			, **_lowerCAmelCase					):

										"""simple docstring"""




										requires_backends(cls			, ['''torch''', '''scipy''']					)



