


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       __magic_name__	(     __lowerCAmelCase					,				unittest.TestCase):
     A:		Optional[int]			=      ShapEPipeline
     A:		Tuple			=      ["prompt"]
     A:		str			=      ["prompt"]
     A:		int			=      [
         "num_images_per_prompt",
         "num_inference_steps",
         "generator",
         "latents",
         "guidance_scale",
         "frame_size",
         "output_type",
         "return_dict",
     ]
     A:		Optional[Any]			=      False


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





      '''simple docstring'''






      return 32


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





      '''simple docstring'''






      return 32


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





      '''simple docstring'''






      return self.time_input_dim * 4


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





      '''simple docstring'''






      return 8


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





      '''simple docstring'''






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


     @property
     def      UpperCAmelCase__	(      self							:     int			)  ->      str:





      '''simple docstring'''






      torch.manual_seed(0			)
      UpperCamelCase__					:    Dict          =   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-0_5							,	num_attention_heads=4							,	num_hidden_layers=5							,	pad_token_id=1							,	vocab_size=1000							,	)
      return CLIPTextModelWithProjection(lowerCamelCase__			)


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





      '''simple docstring'''






      torch.manual_seed(0			)

      UpperCamelCase__					:    List[Any]          =   {
          '''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,
      }

      UpperCamelCase__					:    List[Any]          =   PriorTransformer(**lowerCamelCase__			)
      return model


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





      '''simple docstring'''






      torch.manual_seed(0			)

      UpperCamelCase__					:    Optional[Any]          =   {
          '''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,
          ),
      }
      UpperCamelCase__					:    str          =   ShapERenderer(**lowerCamelCase__			)
      return model


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





      '''simple docstring'''






      UpperCamelCase__					:    Dict          =   self.dummy_prior
      UpperCamelCase__					:    Union[str, Any]          =   self.dummy_text_encoder
      UpperCamelCase__					:    Union[str, Any]          =   self.dummy_tokenizer
      UpperCamelCase__					:    Any          =   self.dummy_renderer

      UpperCamelCase__					:    List[Any]          =   HeunDiscreteScheduler(
          beta_schedule='''exp'''							,	num_train_timesteps=1024							,	prediction_type='''sample'''							,	use_karras_sigmas=lowerCamelCase__							,	clip_sample=lowerCamelCase__							,	clip_sample_range=1.0							,	)
      UpperCamelCase__					:    Tuple          =   {
          '''prior''': prior,
          '''text_encoder''': text_encoder,
          '''tokenizer''': tokenizer,
          '''renderer''': renderer,
          '''scheduler''': scheduler,
      }

      return components


     def      UpperCAmelCase__	(      self							:     List[Any]							,	lowerCamelCase__							:     Union[str, Any]							,	lowerCamelCase__							:     str=0			)  ->      int:





      '''simple docstring'''






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


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





      '''simple docstring'''






      UpperCamelCase__					:    Dict          =   '''cpu'''

      UpperCamelCase__					:    int          =   self.get_dummy_components()

      UpperCamelCase__					:    Tuple          =   self.pipeline_class(**lowerCamelCase__			)
      UpperCamelCase__					:    Union[str, Any]          =   pipe.to(lowerCamelCase__			)

      pipe.set_progress_bar_config(disable=lowerCamelCase__			)

      UpperCamelCase__					:    int          =   pipe(**self.get_dummy_inputs(lowerCamelCase__			)			)
      UpperCamelCase__					:    Union[str, Any]          =   output.images[0]
      UpperCamelCase__					:    int          =   image[0, -3:, -3:, -1]

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

      UpperCamelCase__					:    Union[str, 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							:     int			)  ->      Tuple:





      '''simple docstring'''






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


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





      '''simple docstring'''






      UpperCamelCase__					:    Optional[Any]          =   torch_device == '''cpu'''
      UpperCamelCase__					:    Dict          =   True

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


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





      '''simple docstring'''






      UpperCamelCase__					:    str          =   self.get_dummy_components()
      UpperCamelCase__					:    Union[str, Any]          =   self.pipeline_class(**lowerCamelCase__			)
      UpperCamelCase__					:    Any          =   pipe.to(lowerCamelCase__			)
      pipe.set_progress_bar_config(disable=lowerCamelCase__			)

      UpperCamelCase__					:    str          =   1
      UpperCamelCase__					:    List[str]          =   2

      UpperCamelCase__					:    str          =   self.get_dummy_inputs(lowerCamelCase__			)

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

      UpperCamelCase__					:    Any          =   pipe(**lowerCamelCase__							,	num_images_per_prompt=lowerCamelCase__			)[0]

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



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


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





      '''simple docstring'''






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


     def      UpperCAmelCase__	(      self							:     Union[str, Any]			)  ->      Optional[int]:





      '''simple docstring'''






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

      UpperCamelCase__					:    Dict          =   torch.Generator(device=lowerCamelCase__			).manual_seed(0			)

      UpperCamelCase__					:    Union[str, Any]          =   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 math import factorial, radians

def 			_a  (				SCREAMING_SNAKE_CASE	:				float    , SCREAMING_SNAKE_CASE	:				int = 18    , SCREAMING_SNAKE_CASE	:				int = 10     ):







 """simple docstring"""



 UpperCamelCase__					:    Dict          =   angle_in_degrees - ((angle_in_degrees // 360.0) * 360.0)

 # Converting from degrees to radians
 UpperCamelCase__					:    int          =   radians(SCREAMING_SNAKE_CASE     )

 UpperCamelCase__					:    Tuple          =   angle_in_radians
 UpperCamelCase__					:    str          =   3
 UpperCamelCase__					:    int          =   -1

 for _ in range(SCREAMING_SNAKE_CASE     ):
  result += (b * (angle_in_radians**a)) / factorial(SCREAMING_SNAKE_CASE     )

  UpperCamelCase__					:    List[Any]          =   -b  # One positive term and the next will be negative and so on...
  a += 2  # Increased by 2 for every term.

 return round(SCREAMING_SNAKE_CASE    , SCREAMING_SNAKE_CASE     )


if __name__ == "__main__":
       __import__("doctest").testmod()


