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


		'''simple docstring'''






		lowerCAmelCase_     =   ShapEPipeline
		lowerCAmelCase_     =   ['prompt']
		lowerCAmelCase_     =   ['prompt']
		lowerCAmelCase_     =   [
		    'num_images_per_prompt',
		    'num_inference_steps',
		    'generator',
		    'latents',
		    'guidance_scale',
		    'frame_size',
		    'output_type',
		    'return_dict',
		]
		lowerCAmelCase_     =   False
		@property
		def   _snake_case       (       self     :     Optional[int]		)      ->	str:
				return 3_2
		@property
		def   _snake_case       (       self     :     str		)      ->	Dict:
				return 3_2
		@property
		def   _snake_case       (       self     :     List[str]		)      ->	str:
				return self.time_input_dim * 4
		@property
		def   _snake_case       (       self     :     Any		)      ->	Dict:
				return 8
		@property
		def   _snake_case       (       self     :     Dict		)      ->	Any:
				_lowerCamelCase				   =  CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'		)
				return tokenizer
		@property
		def   _snake_case       (       self     :     Optional[int]		)      ->	Optional[int]:
				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=3_7     ,  layer_norm_eps=1e-05     ,  num_attention_heads=4     ,  num_hidden_layers=5     ,  pad_token_id=1     ,  vocab_size=1_0_0_0     ,  )
				return CLIPTextModelWithProjection(snake_case__		)
		@property
		def   _snake_case       (       self     :     str		)      ->	Optional[int]:
				torch.manual_seed(0		)

				_lowerCamelCase				   =  {
				    'num_attention_heads': 2,
				    'attention_head_dim': 1_6,
				    'embedding_dim': self.time_input_dim,
				    'num_embeddings': 3_2,
				    '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,
				}

				_lowerCamelCase				   =  PriorTransformer(**snake_case__		)
				return model
		@property
		def   _snake_case       (       self     :     str		)      ->	str:
				torch.manual_seed(0		)

				_lowerCamelCase				   =  {
				    'param_shapes': (
				        (self.renderer_dim, 9_3),
				        (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': 1_2,
				    'background': (
				        0.1,
				        0.1,
				        0.1,
				    ),
				}
				_lowerCamelCase				   =  ShapERenderer(**snake_case__		)
				return model
		def   _snake_case       (       self     :     int		)      ->	List[str]:
				_lowerCamelCase				   =  self.dummy_prior
				_lowerCamelCase				   =  self.dummy_text_encoder
				_lowerCamelCase				   =  self.dummy_tokenizer
				_lowerCamelCase				   =  self.dummy_renderer

				_lowerCamelCase				   =  HeunDiscreteScheduler(
				    beta_schedule='exp'     ,  num_train_timesteps=1_0_2_4     ,  prediction_type='sample'     ,  use_karras_sigmas=snake_case__     ,  clip_sample=snake_case__     ,  clip_sample_range=1.0     ,  )
				_lowerCamelCase				   =  {
				    'prior': prior,
				    'text_encoder': text_encoder,
				    'tokenizer': tokenizer,
				    'renderer': renderer,
				    'scheduler': scheduler,
				}

				return components
		def   _snake_case       (       self     :     List[str]     ,  snake_case__     :     int     ,  snake_case__     :     List[Any]=0		)      ->	List[Any]:
				if str(snake_case__		).startswith('mps'		):
						_lowerCamelCase				   =  torch.manual_seed(snake_case__		)
				else:
						_lowerCamelCase				   =  torch.Generator(device=snake_case__		).manual_seed(snake_case__		)
				_lowerCamelCase				   =  {
				    'prompt': 'horse',
				    'generator': generator,
				    'num_inference_steps': 1,
				    'frame_size': 3_2,
				    'output_type': 'np',
				}
				return inputs
		def   _snake_case       (       self     :     str		)      ->	str:
				_lowerCamelCase				   =  'cpu'

				_lowerCamelCase				   =  self.get_dummy_components()

				_lowerCamelCase				   =  self.pipeline_class(**snake_case__		)
				_lowerCamelCase				   =  pipe.to(snake_case__		)

				pipe.set_progress_bar_config(disable=snake_case__		)

				_lowerCamelCase				   =  pipe(**self.get_dummy_inputs(snake_case__		)		)
				_lowerCamelCase				   =  output.images[0]
				_lowerCamelCase				   =  image[0, -3:, -3:, -1]

				assert image.shape == (2_0, 3_2, 3_2, 3)

				_lowerCamelCase				   =  np.array(
				    [
				        0.0003_9216,
				        0.0003_9216,
				        0.0003_9216,
				        0.0003_9216,
				        0.0003_9216,
				        0.0003_9216,
				        0.0003_9216,
				        0.0003_9216,
				        0.0003_9216,
				    ]		)

				assert np.abs(image_slice.flatten() - expected_slice		).max() < 1e-2
		def   _snake_case       (       self     :     Dict		)      ->	List[str]:
				# NOTE: Larger batch sizes cause this test to timeout, only test on smaller batches
				self._test_inference_batch_consistent(batch_sizes=[1, 2]		)
		def   _snake_case       (       self     :     Any		)      ->	Tuple:
				_lowerCamelCase				   =  torch_device == 'cpu'
				_lowerCamelCase				   =  True

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



		def   _snake_case       (       self     :     Optional[Any]		)      ->	Dict:
				_lowerCamelCase				   =  self.get_dummy_components()
				_lowerCamelCase				   =  self.pipeline_class(**snake_case__		)
				_lowerCamelCase				   =  pipe.to(snake_case__		)
				pipe.set_progress_bar_config(disable=snake_case__		)

				_lowerCamelCase				   =  1
				_lowerCamelCase				   =  2

				_lowerCamelCase				   =  self.get_dummy_inputs(snake_case__		)

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

				_lowerCamelCase				   =  pipe(**snake_case__     ,  num_images_per_prompt=snake_case__		)[0]

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





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


		'''simple docstring'''






		def   _snake_case       (       self     :     Union[str, Any]		)      ->	Any:
				# clean up the VRAM after each test
				super().tearDown()
				gc.collect()
				torch.cuda.empty_cache()



		def   _snake_case       (       self     :     Union[str, Any]		)      ->	int:
				_lowerCamelCase				   =  load_numpy(
				    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
				    '/shap_e/test_shap_e_np_out.npy'		)
				_lowerCamelCase				   =  ShapEPipeline.from_pretrained('openai/shap-e'		)
				_lowerCamelCase				   =  pipe.to(snake_case__		)
				pipe.set_progress_bar_config(disable=snake_case__		)

				_lowerCamelCase				   =  torch.Generator(device=snake_case__		).manual_seed(0		)

				_lowerCamelCase				   =  pipe(
				    'a shark'     ,  generator=snake_case__     ,  guidance_scale=15.0     ,  num_inference_steps=6_4     ,  frame_size=6_4     ,  output_type='np'     ,  ).images[0]

				assert images.shape == (2_0, 6_4, 6_4, 3)

				assert_mean_pixel_difference(snake_case__     ,  snake_case__		)
A						=			'\n# Transformers installation\n! pip install transformers datasets\n# To install from source instead of the last release, comment the command above and uncomment the following one.\n# ! pip install git+https://github.com/huggingface/transformers.git\n'

A						=			[{'type': 'code', 'content': INSTALL_CONTENT}]
A						=			{
    '{processor_class}': 'FakeProcessorClass',
    '{model_class}': 'FakeModelClass',
    '{object_class}': 'FakeObjectClass',
}