



"""simple docstring"""





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  UpperCAmelCase__				(       self )			->    List[str]:







								'''simple docstring'''

								return 3_2





		@property
		def  UpperCAmelCase__				(       self )			->    int:







								'''simple docstring'''

								return 3_2





		@property
		def  UpperCAmelCase__				(       self )			->    List[str]:







								'''simple docstring'''

								return self.time_input_dim * 4





		@property
		def  UpperCAmelCase__				(       self )			->    Any:







								'''simple docstring'''

								return 8





		@property
		def  UpperCAmelCase__				(       self )			->    Any:







								'''simple docstring'''

								snake_case_ :			Dict            =      CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip""" )
								return tokenizer





		@property
		def  UpperCAmelCase__				(       self )			->    Optional[Any]:







								'''simple docstring'''

								torch.manual_seed(0 )
								snake_case_ :			Optional[int]            =      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(_lowercase )





		@property
		def  UpperCAmelCase__				(       self )			->    List[Any]:







								'''simple docstring'''

								torch.manual_seed(0 )

								snake_case_ :			Any            =      {
								    """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,
								}

								snake_case_ :			Dict            =      PriorTransformer(**_lowercase )
								return model





		@property
		def  UpperCAmelCase__				(       self )			->    Union[str, Any]:







								'''simple docstring'''

								torch.manual_seed(0 )

								snake_case_ :			Tuple            =      {
								    """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,
								    ),
								}
								snake_case_ :			str            =      ShapERenderer(**_lowercase )
								return model





		def  UpperCAmelCase__				(       self )			->    int:







								'''simple docstring'''

								snake_case_ :			List[str]            =      self.dummy_prior
								snake_case_ :			Dict            =      self.dummy_text_encoder
								snake_case_ :			str            =      self.dummy_tokenizer
								snake_case_ :			List[Any]            =      self.dummy_renderer

								snake_case_ :			Optional[int]            =      HeunDiscreteScheduler(
								    beta_schedule="""exp"""				,     num_train_timesteps=1_0_2_4				,     prediction_type="""sample"""				,     use_karras_sigmas=_lowercase				,     clip_sample=_lowercase				,     clip_sample_range=1.0				,     )
								snake_case_ :			Optional[int]            =      {
								    """prior""": prior,
								    """text_encoder""": text_encoder,
								    """tokenizer""": tokenizer,
								    """renderer""": renderer,
								    """scheduler""": scheduler,
								}

								return components





		def  UpperCAmelCase__				(       self				,     _lowercase				,     _lowercase=0 )			->    List[Any]:







								'''simple docstring'''

								if str(_lowercase ).startswith("""mps""" ):
														snake_case_ :			Tuple            =      torch.manual_seed(_lowercase )
								else:
														snake_case_ :			str            =      torch.Generator(device=_lowercase ).manual_seed(_lowercase )
								snake_case_ :			List[Any]            =      {
								    """prompt""": """horse""",
								    """generator""": generator,
								    """num_inference_steps""": 1,
								    """frame_size""": 3_2,
								    """output_type""": """np""",
								}
								return inputs





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







								'''simple docstring'''

								snake_case_ :			int            =      """cpu"""

								snake_case_ :			Union[str, Any]            =      self.get_dummy_components()

								snake_case_ :			List[str]            =      self.pipeline_class(**_lowercase )
								snake_case_ :			Any            =      pipe.to(_lowercase )

								pipe.set_progress_bar_config(disable=_lowercase )

								snake_case_ :			str            =      pipe(**self.get_dummy_inputs(_lowercase ) )
								snake_case_ :			List[Any]            =      output.images[0]
								snake_case_ :			Tuple            =      image[0, -3:, -3:, -1]

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

								snake_case_ :			List[Any]            =      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  UpperCAmelCase__				(       self )			->    Dict:







								'''simple docstring'''

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





		def  UpperCAmelCase__				(       self )			->    List[str]:







								'''simple docstring'''

								snake_case_ :			Dict            =      torch_device == """cpu"""
								snake_case_ :			Optional[Any]            =      True

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





		def  UpperCAmelCase__				(       self )			->    Tuple:







								'''simple docstring'''

								snake_case_ :			Dict            =      self.get_dummy_components()
								snake_case_ :			Optional[Any]            =      self.pipeline_class(**_lowercase )
								snake_case_ :			Dict            =      pipe.to(_lowercase )
								pipe.set_progress_bar_config(disable=_lowercase )

								snake_case_ :			Optional[Any]            =      1
								snake_case_ :			str            =      2

								snake_case_ :			int            =      self.get_dummy_inputs(_lowercase )

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

								snake_case_ :			List[Any]            =      pipe(**_lowercase				,     num_images_per_prompt=_lowercase )[0]

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




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





		"""simple docstring"""






		def  UpperCAmelCase__				(       self )			->    str:







								'''simple docstring'''

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





		def  UpperCAmelCase__				(       self )			->    int:







								'''simple docstring'''

								snake_case_ :			str            =      load_numpy(
								    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
								    """/shap_e/test_shap_e_np_out.npy""" )
								snake_case_ :			Union[str, Any]            =      ShapEPipeline.from_pretrained("""openai/shap-e""" )
								snake_case_ :			str            =      pipe.to(_lowercase )
								pipe.set_progress_bar_config(disable=_lowercase )

								snake_case_ :			Tuple            =      torch.Generator(device=_lowercase ).manual_seed(0 )

								snake_case_ :			List[Any]            =      pipe(
								    """a shark"""				,     generator=_lowercase				,     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(_lowercase				,     _lowercase )






'''simple docstring'''






from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_torch_available,
)


lowerCAmelCase:   List[str]					=		{
    'configuration_falcon': ['FALCON_PRETRAINED_CONFIG_ARCHIVE_MAP', 'FalconConfig'],
}

try:
     if not is_torch_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     lowerCAmelCase:   str					=		[
         'FALCON_PRETRAINED_MODEL_ARCHIVE_LIST',
         'FalconForCausalLM',
         'FalconModel',
         'FalconPreTrainedModel',
         'FalconForSequenceClassification',
         'FalconForTokenClassification',
         'FalconForQuestionAnswering',
     ]


if TYPE_CHECKING:
     from .configuration_falcon import FALCON_PRETRAINED_CONFIG_ARCHIVE_MAP, FalconConfig

     try:
          if not is_torch_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_falcon import (
              FALCON_PRETRAINED_MODEL_ARCHIVE_LIST,
              FalconForCausalLM,
              FalconForQuestionAnswering,
              FalconForSequenceClassification,
              FalconForTokenClassification,
              FalconModel,
              FalconPreTrainedModel,
          )


else:
     import sys

     lowerCAmelCase:   Optional[int]					=		_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)