



"""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      UpperCAmelCase_  (    _UpperCamelCase	,      unittest.TestCase						):
      __SCREAMING_SNAKE_CASE						:       Tuple								=			ShapEPipeline
      __SCREAMING_SNAKE_CASE						:       Dict								=			['prompt']
      __SCREAMING_SNAKE_CASE						:       int								=			['prompt']
      __SCREAMING_SNAKE_CASE						:       List[str]								=			[
          'num_images_per_prompt',
          'num_inference_steps',
          'generator',
          'latents',
          'guidance_scale',
          'frame_size',
          'output_type',
          'return_dict',
      ]
      __SCREAMING_SNAKE_CASE						:       Dict								=			False



      @property
      def 						snake_case_ (					self					:     Tuple						):
           return 3_2



      @property
      def 						snake_case_ (					self					:     Any						):
           return 3_2



      @property
      def 						snake_case_ (					self					:     List[Any]						):
           return self.time_input_dim * 4



      @property
      def 						snake_case_ (					self					:     Optional[int]						):
           return 8



      @property
      def 						snake_case_ (					self					:     Dict						):
           _UpperCAmelCase      :     Any        =   CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"						)
           return tokenizer



      @property
      def 						snake_case_ (					self					:     Optional[Any]						):
           torch.manual_seed(0						)
           _UpperCAmelCase      :     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=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(A						)



      @property
      def 						snake_case_ (					self					:     Any						):
           torch.manual_seed(0						)

           _UpperCAmelCase      :     int        =   {
               "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,
           }

           _UpperCAmelCase      :     Tuple        =   PriorTransformer(**A						)
           return model



      @property
      def 						snake_case_ (					self					:     Dict						):
           torch.manual_seed(0						)

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



      def 						snake_case_ (					self					:     Union[str, Any]						):
           _UpperCAmelCase      :     Union[str, Any]        =   self.dummy_prior
           _UpperCAmelCase      :     Dict        =   self.dummy_text_encoder
           _UpperCAmelCase      :     int        =   self.dummy_tokenizer
           _UpperCAmelCase      :     List[Any]        =   self.dummy_renderer

           _UpperCAmelCase      :     Any        =   HeunDiscreteScheduler(
               beta_schedule="exp"					,     num_train_timesteps=1_0_2_4					,     prediction_type="sample"					,     use_karras_sigmas=A					,     clip_sample=A					,     clip_sample_range=1.0					,     )
           _UpperCAmelCase      :     int        =   {
               "prior": prior,
               "text_encoder": text_encoder,
               "tokenizer": tokenizer,
               "renderer": renderer,
               "scheduler": scheduler,
           }

           return components



      def 						snake_case_ (					self					:     Optional[Any]					,     A					:     List[Any]					,     A					:     Dict=0						):
           if str(A						).startswith("mps"						):
                _UpperCAmelCase      :     Union[str, Any]        =   torch.manual_seed(A						)
           else:
                _UpperCAmelCase      :     str        =   torch.Generator(device=A						).manual_seed(A						)
           _UpperCAmelCase      :     Any        =   {
               "prompt": "horse",
               "generator": generator,
               "num_inference_steps": 1,
               "frame_size": 3_2,
               "output_type": "np",
           }
           return inputs



      def 						snake_case_ (					self					:     int						):
           _UpperCAmelCase      :     Any        =   "cpu"

           _UpperCAmelCase      :     Dict        =   self.get_dummy_components()

           _UpperCAmelCase      :     Union[str, Any]        =   self.pipeline_class(**A						)
           _UpperCAmelCase      :     Any        =   pipe.to(A						)

           pipe.set_progress_bar_config(disable=A						)

           _UpperCAmelCase      :     str        =   pipe(**self.get_dummy_inputs(A						)						)
           _UpperCAmelCase      :     Dict        =   output.images[0]
           _UpperCAmelCase      :     Any        =   image[0, -3:, -3:, -1]

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

           _UpperCAmelCase      :     Dict        =   np.array(
               [
                   0.00_039_216,
                   0.00_039_216,
                   0.00_039_216,
                   0.00_039_216,
                   0.00_039_216,
                   0.00_039_216,
                   0.00_039_216,
                   0.00_039_216,
                   0.00_039_216,
               ]						)

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



      def 						snake_case_ (					self					:     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 						snake_case_ (					self					:     List[str]						):
           _UpperCAmelCase      :     Union[str, Any]        =   torch_device == "cpu"
           _UpperCAmelCase      :     List[str]        =   True

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



      def 						snake_case_ (					self					:     List[Any]						):
           _UpperCAmelCase      :     int        =   self.get_dummy_components()
           _UpperCAmelCase      :     List[Any]        =   self.pipeline_class(**A						)
           _UpperCAmelCase      :     int        =   pipe.to(A						)
           pipe.set_progress_bar_config(disable=A						)

           _UpperCAmelCase      :     Any        =   1
           _UpperCAmelCase      :     Union[str, Any]        =   2

           _UpperCAmelCase      :     Dict        =   self.get_dummy_inputs(A						)

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

           _UpperCAmelCase      :     Any        =   pipe(**A					,     num_images_per_prompt=A						)[0]

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







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



      def 						snake_case_ (					self					:     Any						):
           # clean up the VRAM after each test
           super().tearDown()
           gc.collect()
           torch.cuda.empty_cache()



      def 						snake_case_ (					self					:     Optional[int]						):
           _UpperCAmelCase      :     Optional[int]        =   load_numpy(
               "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
               "/shap_e/test_shap_e_np_out.npy"						)
           _UpperCAmelCase      :     int        =   ShapEPipeline.from_pretrained("openai/shap-e"						)
           _UpperCAmelCase      :     Optional[Any]        =   pipe.to(A						)
           pipe.set_progress_bar_config(disable=A						)

           _UpperCAmelCase      :     Optional[Any]        =   torch.Generator(device=A						).manual_seed(0						)

           _UpperCAmelCase      :     int        =   pipe(
               "a shark"					,     generator=A					,     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(A					,     A						)





"""simple docstring"""




from typing import Dict, Iterable, List, Optional, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import (
    center_crop,
    get_resize_output_image_size,
    normalize,
    rescale,
    resize,
    to_channel_dimension_format,
)
from ...image_utils import (
    IMAGENET_DEFAULT_MEAN,
    IMAGENET_DEFAULT_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, logging


_lowerCAmelCase    : Tuple							=							logging.get_logger(__name__)






class      UpperCAmelCase_  (    _UpperCamelCase						):
      __SCREAMING_SNAKE_CASE						:       str								=			['pixel_values']



      def __init__(					self					:     List[Any]					,     A					:     bool = True					,     A					:     Dict[str, int] = None					,     A					:     PILImageResampling = PILImageResampling.BICUBIC					,     A					:     bool = True					,     A					:     Dict[str, int] = None					,     A					:     bool = True					,     A					:     Union[int, float] = 1 / 2_5_5					,     A					:     bool = True					,     A					:     Optional[Union[float, Iterable[float]]] = IMAGENET_DEFAULT_MEAN					,     A					:     Optional[Union[float, Iterable[float]]] = IMAGENET_DEFAULT_STD					,     **A					:     List[Any]					,     ):
           super().__init__(**A						)
           _UpperCAmelCase      :     int        =   size if size is not None else {"shortest_edge": 2_2_4}
           _UpperCAmelCase      :     Tuple        =   get_size_dict(A					,     default_to_square=A						)
           _UpperCAmelCase      :     int        =   crop_size if crop_size is not None else {"height": 2_2_4, "width": 2_2_4}
           _UpperCAmelCase      :     Union[str, Any]        =   get_size_dict(A					,     param_name="crop_size"						)

           _UpperCAmelCase      :     str        =   do_resize
           _UpperCAmelCase      :     Union[str, Any]        =   size
           _UpperCAmelCase      :     Tuple        =   resample
           _UpperCAmelCase      :     List[Any]        =   do_center_crop
           _UpperCAmelCase      :     List[Any]        =   crop_size
           _UpperCAmelCase      :     Tuple        =   do_rescale
           _UpperCAmelCase      :     List[Any]        =   rescale_factor
           _UpperCAmelCase      :     Dict        =   do_normalize
           _UpperCAmelCase      :     Optional[Any]        =   image_mean if image_mean is not None else IMAGENET_DEFAULT_MEAN
           _UpperCAmelCase      :     Any        =   image_std if image_std is not None else IMAGENET_DEFAULT_STD



      def 						snake_case_ (					self					:     Optional[int]					,     A					:     np.ndarray					,     A					:     Dict[str, int]					,     A					:     PILImageResampling = PILImageResampling.BICUBIC					,     A					:     Optional[Union[str, ChannelDimension]] = None					,     **A					:     Union[str, Any]					,     ):
           _UpperCAmelCase      :     Tuple        =   get_size_dict(A					,     default_to_square=A						)
           # size_dict is a dict with either keys "height" and "width" or "shortest_edge"
           if "shortest_edge" in size:
                _UpperCAmelCase      :     Any        =   int((2_5_6 / 2_2_4) * size["shortest_edge"]						)
                _UpperCAmelCase      :     Union[str, Any]        =   get_resize_output_image_size(A					,     size=A					,     default_to_square=A						)
                _UpperCAmelCase      :     str        =   {"height": output_size[0], "width": output_size[1]}
           if "height" not in size_dict or "width" not in size_dict:
                raise ValueError(
                    f'Size dict must have keys \'height\' and \'width\' or \'shortest_edge\'. Got {size_dict.keys()}'						)
           return resize(
               A					,     size=(size_dict["height"], size_dict["width"])					,     resample=A					,     data_format=A					,     **A						)



      def 						snake_case_ (					self					:     int					,     A					:     np.ndarray					,     A					:     Dict[str, int]					,     A					:     Optional[Union[str, ChannelDimension]] = None					,     **A					:     Optional[Any]					,     ):
           _UpperCAmelCase      :     Dict        =   get_size_dict(A						)
           if "height" not in size or "width" not in size:
                raise ValueError(f'Size dict must have keys \'height\' and \'width\'. Got {size.keys()}'						)
           return center_crop(A					,     size=(size["height"], size["width"])					,     data_format=A					,     **A						)



      def 						snake_case_ (					self					:     List[str]					,     A					:     np.ndarray					,     A					:     Union[int, float]					,     A					:     Optional[Union[str, ChannelDimension]] = None					,     **A					:     Dict					,     ):
           return rescale(A					,     scale=A					,     data_format=A					,     **A						)



      def 						snake_case_ (					self					:     List[str]					,     A					:     np.ndarray					,     A					:     Union[float, List[float]]					,     A					:     Union[float, List[float]]					,     A					:     Optional[Union[str, ChannelDimension]] = None					,     **A					:     str					,     ):
           return normalize(A					,     mean=A					,     std=A					,     data_format=A					,     **A						)



      def 						snake_case_ (					self					:     Tuple					,     A					:     ImageInput					,     A					:     Optional[bool] = None					,     A					:     Optional[Dict[str, int]] = None					,     A					:     PILImageResampling = None					,     A					:     Optional[bool] = None					,     A					:     Optional[Dict[str, int]] = None					,     A					:     Optional[bool] = None					,     A					:     Optional[float] = None					,     A					:     Optional[bool] = None					,     A					:     Optional[Union[float, Iterable[float]]] = None					,     A					:     Optional[Union[float, Iterable[float]]] = None					,     A					:     Optional[TensorType] = None					,     A					:     ChannelDimension = ChannelDimension.FIRST					,     **A					:     Dict					,     ):
           _UpperCAmelCase      :     Dict        =   do_resize if do_resize is not None else self.do_resize
           _UpperCAmelCase      :     List[str]        =   resample if resample is not None else self.resample
           _UpperCAmelCase      :     int        =   do_center_crop if do_center_crop is not None else self.do_center_crop
           _UpperCAmelCase      :     str        =   do_rescale if do_rescale is not None else self.do_rescale
           _UpperCAmelCase      :     Tuple        =   rescale_factor if rescale_factor is not None else self.rescale_factor
           _UpperCAmelCase      :     Optional[int]        =   do_normalize if do_normalize is not None else self.do_normalize
           _UpperCAmelCase      :     List[str]        =   image_mean if image_mean is not None else self.image_mean
           _UpperCAmelCase      :     Tuple        =   image_std if image_std is not None else self.image_std

           _UpperCAmelCase      :     Any        =   size if size is not None else self.size
           _UpperCAmelCase      :     Optional[int]        =   get_size_dict(A					,     default_to_square=A						)
           _UpperCAmelCase      :     List[str]        =   crop_size if crop_size is not None else self.crop_size
           _UpperCAmelCase      :     List[str]        =   get_size_dict(A					,     param_name="crop_size"						)

           _UpperCAmelCase      :     List[Any]        =   make_list_of_images(A						)

           if not valid_images(A						):
                raise ValueError(
                    "Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, "
                    "torch.Tensor, tf.Tensor or jax.ndarray."						)

           if do_resize and size is None:
                raise ValueError("Size must be specified if do_resize is True."						)

           if do_center_crop and crop_size is None:
                raise ValueError("Crop size must be specified if do_center_crop is True."						)

           if do_rescale and rescale_factor is None:
                raise ValueError("Rescale factor must be specified if do_rescale is True."						)

           if do_normalize and (image_mean is None or image_std is None):
                raise ValueError("Image mean and std must be specified if do_normalize is True."						)

           # All transformations expect numpy arrays.
           _UpperCAmelCase      :     Any        =   [to_numpy_array(A						) for image in images]

           if do_resize:
                _UpperCAmelCase      :     str        =   [self.resize(A					,     A					,     A						) for image in images]

           if do_center_crop:
                _UpperCAmelCase      :     Dict        =   [self.center_crop(A					,     A						) for image in images]

           if do_rescale:
                _UpperCAmelCase      :     Dict        =   [self.rescale(A					,     A						) for image in images]

           if do_normalize:
                _UpperCAmelCase      :     Optional[int]        =   [self.normalize(A					,     A					,     A						) for image in images]

           _UpperCAmelCase      :     Union[str, Any]        =   [to_channel_dimension_format(A					,     A						) for image in images]

           _UpperCAmelCase      :     List[Any]        =   {"pixel_values": images}
           return BatchFeature(data=A					,     tensor_type=A						)
