



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_    ( _A						,unittest.TestCase						):






						'''simple docstring'''
						a__   =  ShapEPipeline
						a__   =  ["prompt"]
						a__   =  ["prompt"]
						a__   =  [
						    "num_images_per_prompt",
						    "num_inference_steps",
						    "generator",
						    "latents",
						    "guidance_scale",
						    "frame_size",
						    "output_type",
						    "return_dict",
						]
						a__   =  False







						@property
						def 			SCREAMING_SNAKE_CASE__		(	self      :			List[Any] )      ->				Any:
									return 32







						@property
						def 			SCREAMING_SNAKE_CASE__		(	self      :			List[str] )      ->				int:
									return 32







						@property
						def 			SCREAMING_SNAKE_CASE__		(	self      :			List[Any] )      ->				Optional[Any]:
									return self.time_input_dim * 4







						@property
						def 			SCREAMING_SNAKE_CASE__		(	self      :			Optional[Any] )      ->				int:
									return 8







						@property
						def 			SCREAMING_SNAKE_CASE__		(	self      :			Union[str, Any] )      ->				Tuple:
									A							:					str              =						CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip" )
									return tokenizer







						@property
						def 			SCREAMING_SNAKE_CASE__		(	self      :			Dict )      ->				int:
									torch.manual_seed(0 )
									A							:					Any              =						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=10_00	,	)
									return CLIPTextModelWithProjection(__lowerCamelCase )







						@property
						def 			SCREAMING_SNAKE_CASE__		(	self      :			Any )      ->				str:
									torch.manual_seed(0 )

									A							:					Tuple              =						{
									    "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,
									}

									A							:					List[Any]              =						PriorTransformer(**__lowerCamelCase )
									return model







						@property
						def 			SCREAMING_SNAKE_CASE__		(	self      :			str )      ->				List[str]:
									torch.manual_seed(0 )

									A							:					Dict              =						{
									    "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,
									    ),
									}
									A							:					Optional[Any]              =						ShapERenderer(**__lowerCamelCase )
									return model







						def 			SCREAMING_SNAKE_CASE__		(	self      :			Optional[Any] )      ->				Optional[int]:
									A							:					List[str]              =						self.dummy_prior
									A							:					Dict              =						self.dummy_text_encoder
									A							:					Optional[Any]              =						self.dummy_tokenizer
									A							:					Union[str, Any]              =						self.dummy_renderer

									A							:					str              =						HeunDiscreteScheduler(
									    beta_schedule="exp"	,	num_train_timesteps=10_24	,	prediction_type="sample"	,	use_karras_sigmas=__lowerCamelCase	,	clip_sample=__lowerCamelCase	,	clip_sample_range=1.0	,	)
									A							:					Union[str, Any]              =						{
									    "prior": prior,
									    "text_encoder": text_encoder,
									    "tokenizer": tokenizer,
									    "renderer": renderer,
									    "scheduler": scheduler,
									}

									return components







						def 			SCREAMING_SNAKE_CASE__		(	self      :			Union[str, Any]	,	__lowerCamelCase      :			int	,	__lowerCamelCase      :			Optional[int]=0 )      ->				List[Any]:
									if str(__lowerCamelCase ).startswith("mps" ):
												A							:					Dict              =						torch.manual_seed(__lowerCamelCase )
									else:
												A							:					List[Any]              =						torch.Generator(device=__lowerCamelCase ).manual_seed(__lowerCamelCase )
									A							:					List[Any]              =						{
									    "prompt": "horse",
									    "generator": generator,
									    "num_inference_steps": 1,
									    "frame_size": 32,
									    "output_type": "np",
									}
									return inputs







						def 			SCREAMING_SNAKE_CASE__		(	self      :			Optional[int] )      ->				str:
									A							:					List[Any]              =						"cpu"

									A							:					Optional[Any]              =						self.get_dummy_components()

									A							:					int              =						self.pipeline_class(**__lowerCamelCase )
									A							:					List[Any]              =						pipe.to(__lowerCamelCase )

									pipe.set_progress_bar_config(disable=__lowerCamelCase )

									A							:					Optional[int]              =						pipe(**self.get_dummy_inputs(__lowerCamelCase ) )
									A							:					str              =						output.images[0]
									A							:					Optional[int]              =						image[0, -3:, -3:, -1]

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

									A							:					int              =						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 			SCREAMING_SNAKE_CASE__		(	self      :			List[str] )      ->				Optional[int]:
									# NOTE: Larger batch sizes cause this test to timeout, only test on smaller batches
									self._test_inference_batch_consistent(batch_sizes=[1, 2] )







						def 			SCREAMING_SNAKE_CASE__		(	self      :			str )      ->				Tuple:
									A							:					List[Any]              =						torch_device == "cpu"
									A							:					Optional[int]              =						True

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







						def 			SCREAMING_SNAKE_CASE__		(	self      :			int )      ->				Optional[int]:
									A							:					str              =						self.get_dummy_components()
									A							:					Tuple              =						self.pipeline_class(**__lowerCamelCase )
									A							:					int              =						pipe.to(__lowerCamelCase )
									pipe.set_progress_bar_config(disable=__lowerCamelCase )

									A							:					List[Any]              =						1
									A							:					Tuple              =						2

									A							:					str              =						self.get_dummy_inputs(__lowerCamelCase )

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

									A							:					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 	lowerCamelCase_    ( unittest.TestCase						):






						'''simple docstring'''







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







						def 			SCREAMING_SNAKE_CASE__		(	self      :			int )      ->				List[str]:
									A							:					Tuple              =						load_numpy(
									    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
									    "/shap_e/test_shap_e_np_out.npy" )
									A							:					str              =						ShapEPipeline.from_pretrained("openai/shap-e" )
									A							:					List[str]              =						pipe.to(__lowerCamelCase )
									pipe.set_progress_bar_config(disable=__lowerCamelCase )

									A							:					List[str]              =						torch.Generator(device=__lowerCamelCase ).manual_seed(0 )

									A							:					Dict              =						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 typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


__SCREAMING_SNAKE_CASE           =  {
    """configuration_instructblip""": [
        """INSTRUCTBLIP_PRETRAINED_CONFIG_ARCHIVE_MAP""",
        """InstructBlipConfig""",
        """InstructBlipQFormerConfig""",
        """InstructBlipVisionConfig""",
    ],
    """processing_instructblip""": ["""InstructBlipProcessor"""],
}

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							__SCREAMING_SNAKE_CASE           =  [
							    """INSTRUCTBLIP_PRETRAINED_MODEL_ARCHIVE_LIST""",
							    """InstructBlipQFormerModel""",
							    """InstructBlipPreTrainedModel""",
							    """InstructBlipForConditionalGeneration""",
							    """InstructBlipVisionModel""",
							]

if TYPE_CHECKING:
							from .configuration_instructblip import (
							    INSTRUCTBLIP_PRETRAINED_CONFIG_ARCHIVE_MAP,
							    InstructBlipConfig,
							    InstructBlipQFormerConfig,
							    InstructBlipVisionConfig,
							)
							from .processing_instructblip import InstructBlipProcessor

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_instructblip import (
														    INSTRUCTBLIP_PRETRAINED_MODEL_ARCHIVE_LIST,
														    InstructBlipForConditionalGeneration,
														    InstructBlipPreTrainedModel,
														    InstructBlipQFormerModel,
														    InstructBlipVisionModel,
														)

else:
							import sys

							__SCREAMING_SNAKE_CASE           =  _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)