

'''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 							A__    (       A__     ,   unittest.TestCase  ):
  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 						A  (		self      :	int )	->    int:





       '''simple docstring'''






       return 32





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





       '''simple docstring'''






       return 32





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





       '''simple docstring'''






       return self.time_input_dim * 4





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





       '''simple docstring'''






       return 8





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





       '''simple docstring'''






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





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





       '''simple docstring'''






       torch.manual_seed(0 )
       _SCREAMING_SNAKE_CASE							    =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(_a )





  @property
  def 						A  (		self      :	Tuple )	->    int:





       '''simple docstring'''






       torch.manual_seed(0 )

       _SCREAMING_SNAKE_CASE							    ={
           '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							    =PriorTransformer(**_a )
       return model





  @property
  def 						A  (		self      :	Dict )	->    Any:





       '''simple docstring'''






       torch.manual_seed(0 )

       _SCREAMING_SNAKE_CASE							    ={
           '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							    =ShapERenderer(**_a )
       return model





  def 						A  (		self      :	Union[str, Any] )	->    Tuple:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =self.dummy_prior
       _SCREAMING_SNAKE_CASE							    =self.dummy_text_encoder
       _SCREAMING_SNAKE_CASE							    =self.dummy_tokenizer
       _SCREAMING_SNAKE_CASE							    =self.dummy_renderer

       _SCREAMING_SNAKE_CASE							    =HeunDiscreteScheduler(
           beta_schedule='exp'							,					num_train_timesteps=1024							,					prediction_type='sample'							,					use_karras_sigmas=_a							,					clip_sample=_a							,					clip_sample_range=1.0							,					)
       _SCREAMING_SNAKE_CASE							    ={
           'prior': prior,
           'text_encoder': text_encoder,
           'tokenizer': tokenizer,
           'renderer': renderer,
           'scheduler': scheduler,
       }

       return components





  def 						A  (		self      :	int							,					_a      :	Optional[Any]							,					_a      :	Any=0 )	->    Union[str, Any]:





       '''simple docstring'''






       if str(_a ).startswith('mps' ):
            _SCREAMING_SNAKE_CASE							    =torch.manual_seed(_a )
       else:
            _SCREAMING_SNAKE_CASE							    =torch.Generator(device=_a ).manual_seed(_a )
       _SCREAMING_SNAKE_CASE							    ={
           'prompt': 'horse',
           'generator': generator,
           'num_inference_steps': 1,
           'frame_size': 32,
           'output_type': 'np',
       }
       return inputs





  def 						A  (		self      :	int )	->    List[Any]:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    ='cpu'

       _SCREAMING_SNAKE_CASE							    =self.get_dummy_components()

       _SCREAMING_SNAKE_CASE							    =self.pipeline_class(**_a )
       _SCREAMING_SNAKE_CASE							    =pipe.to(_a )

       pipe.set_progress_bar_config(disable=_a )

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

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

       _SCREAMING_SNAKE_CASE							    =np.array(
           [
               0.00_03_92_16,
               0.00_03_92_16,
               0.00_03_92_16,
               0.00_03_92_16,
               0.00_03_92_16,
               0.00_03_92_16,
               0.00_03_92_16,
               0.00_03_92_16,
               0.00_03_92_16,
           ] )

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





  def 						A  (		self      :	Dict )	->    List[str]:





       '''simple docstring'''






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





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





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =torch_device == 'cpu'
       _SCREAMING_SNAKE_CASE							    =True

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





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





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =self.get_dummy_components()
       _SCREAMING_SNAKE_CASE							    =self.pipeline_class(**_a )
       _SCREAMING_SNAKE_CASE							    =pipe.to(_a )
       pipe.set_progress_bar_config(disable=_a )

       _SCREAMING_SNAKE_CASE							    =1
       _SCREAMING_SNAKE_CASE							    =2

       _SCREAMING_SNAKE_CASE							    =self.get_dummy_inputs(_a )

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

       _SCREAMING_SNAKE_CASE							    =pipe(**_a							,					num_images_per_prompt=_a )[0]

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







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





  def 						A  (		self      :	str )	->    Any:





       '''simple docstring'''






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





  def 						A  (		self      :	Optional[Any] )	->    Dict:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =load_numpy(
           'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
           '/shap_e/test_shap_e_np_out.npy' )
       _SCREAMING_SNAKE_CASE							    =ShapEPipeline.from_pretrained('openai/shap-e' )
       _SCREAMING_SNAKE_CASE							    =pipe.to(_a )
       pipe.set_progress_bar_config(disable=_a )

       _SCREAMING_SNAKE_CASE							    =torch.Generator(device=_a ).manual_seed(0 )

       _SCREAMING_SNAKE_CASE							    =pipe(
           'a shark'							,					generator=_a							,					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(_a							,					_a )


__A				={str(digit): digit**5 for digit in range(1_0)}





def 			lowerCamelCase_ (				lowerCamelCase__    ):
				return sum(DIGITS_FIFTH_POWER[digit] for digit in str(lowerCamelCase__    )    )





def 			lowerCamelCase_ (				):
				return sum(
				    number
				    for number in range(1_0_0_0	, 1_0_0_0_0_0_0    )
				    if number == digits_fifth_powers_sum(lowerCamelCase__    )    )


if __name__ == "__main__":
			print(solution())


