


'''simple docstring'''

import gc
import random
import unittest

import numpy as np
import torch
from transformers import CLIPImageProcessor, CLIPVisionConfig, CLIPVisionModel

from diffusers import HeunDiscreteScheduler, PriorTransformer, ShapEImgaImgPipeline
from diffusers.pipelines.shap_e import ShapERenderer
from diffusers.utils import floats_tensor, load_image, 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   snake_case					(					lowercase    ,		unittest.TestCase    ):





  """simple docstring"""




  _lowerCamelCase						=						ShapEImgaImgPipeline
  _lowerCamelCase						=						["image"]
  _lowerCamelCase						=						["image"]
  _lowerCamelCase						=						[
      "num_images_per_prompt",
      "num_inference_steps",
      "generator",
      "latents",
      "guidance_scale",
      "frame_size",
      "output_type",
      "return_dict",
  ]
  _lowerCamelCase						=						False






  @property
  def 						snake_case	(					self  ):







   """simple docstring"""
   return 32






  @property
  def 						snake_case	(					self  ):







   """simple docstring"""
   return 32






  @property
  def 						snake_case	(					self  ):







   """simple docstring"""
   return self.time_input_dim * 4






  @property
  def 						snake_case	(					self  ):







   """simple docstring"""
   return 8






  @property
  def 						snake_case	(					self  ):







   """simple docstring"""
   torch.manual_seed(0  )
   lowerCamelCase_  				=						CLIPVisionConfig(
       hidden_size=self.text_embedder_hidden_size    ,						image_size=64    ,						projection_dim=self.text_embedder_hidden_size    ,						intermediate_size=37    ,						num_attention_heads=4    ,						num_channels=3    ,						num_hidden_layers=5    ,						patch_size=1    ,						)

   lowerCamelCase_  				=						CLIPVisionModel(UpperCamelCase  )
   return model






  @property
  def 						snake_case	(					self  ):







   """simple docstring"""
   lowerCamelCase_  				=						CLIPImageProcessor(
       crop_size=224    ,						do_center_crop=UpperCamelCase    ,						do_normalize=UpperCamelCase    ,						do_resize=UpperCamelCase    ,						image_mean=[0.48_145_466, 0.4_578_275, 0.40_821_073]    ,						image_std=[0.26_862_954, 0.26_130_258, 0.27_577_711]    ,						resample=3    ,						size=224    ,						)

   return image_processor






  @property
  def 						snake_case	(					self  ):







   """simple docstring"""
   torch.manual_seed(0  )

   lowerCamelCase_  				=						{
       "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",
       "embedding_proj_norm_type": "layer",
       "encoder_hid_proj_type": None,
       "added_emb_type": None,
   }

   lowerCamelCase_  				=						PriorTransformer(**UpperCamelCase  )
   return model






  @property
  def 						snake_case	(					self  ):







   """simple docstring"""
   torch.manual_seed(0  )

   lowerCamelCase_  				=						{
       "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,
       ),
   }
   lowerCamelCase_  				=						ShapERenderer(**UpperCamelCase  )
   return model






  def 						snake_case	(					self  ):







   """simple docstring"""
   lowerCamelCase_  				=						self.dummy_prior
   lowerCamelCase_  				=						self.dummy_image_encoder
   lowerCamelCase_  				=						self.dummy_image_processor
   lowerCamelCase_  				=						self.dummy_renderer

   lowerCamelCase_  				=						HeunDiscreteScheduler(
       beta_schedule="exp"    ,						num_train_timesteps=1024    ,						prediction_type="sample"    ,						use_karras_sigmas=UpperCamelCase    ,						clip_sample=UpperCamelCase    ,						clip_sample_range=1.0    ,						)
   lowerCamelCase_  				=						{
       "prior": prior,
       "image_encoder": image_encoder,
       "image_processor": image_processor,
       "renderer": renderer,
       "scheduler": scheduler,
   }

   return components






  def 						snake_case	(					self    ,						UpperCamelCase    ,						UpperCamelCase=0  ):







   """simple docstring"""
   lowerCamelCase_  				=						floats_tensor((1, 3, 64, 64)    ,						rng=random.Random(UpperCamelCase  )  ).to(UpperCamelCase  )

   if str(UpperCamelCase  ).startswith("mps"  ):
    lowerCamelCase_  				=						torch.manual_seed(UpperCamelCase  )
   else:
    lowerCamelCase_  				=						torch.Generator(device=UpperCamelCase  ).manual_seed(UpperCamelCase  )
   lowerCamelCase_  				=						{
       "image": input_image,
       "generator": generator,
       "num_inference_steps": 1,
       "frame_size": 32,
       "output_type": "np",
   }
   return inputs






  def 						snake_case	(					self  ):







   """simple docstring"""
   lowerCamelCase_  				=						"cpu"

   lowerCamelCase_  				=						self.get_dummy_components()

   lowerCamelCase_  				=						self.pipeline_class(**UpperCamelCase  )
   lowerCamelCase_  				=						pipe.to(UpperCamelCase  )

   pipe.set_progress_bar_config(disable=UpperCamelCase  )

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

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

   lowerCamelCase_  				=						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  ):







   """simple docstring"""
   # 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  ):







   """simple docstring"""
   lowerCamelCase_  				=						torch_device == "cpu"
   lowerCamelCase_  				=						True
   self._test_inference_batch_single_identical(
       batch_size=2    ,						test_max_difference=UpperCamelCase    ,						relax_max_difference=UpperCamelCase    ,						)







  def 						snake_case	(					self  ):







   """simple docstring"""
   lowerCamelCase_  				=						self.get_dummy_components()
   lowerCamelCase_  				=						self.pipeline_class(**UpperCamelCase  )
   lowerCamelCase_  				=						pipe.to(UpperCamelCase  )
   pipe.set_progress_bar_config(disable=UpperCamelCase  )

   lowerCamelCase_  				=						1
   lowerCamelCase_  				=						2

   lowerCamelCase_  				=						self.get_dummy_inputs(UpperCamelCase  )

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

   lowerCamelCase_  				=						pipe(**UpperCamelCase    ,						num_images_per_prompt=UpperCamelCase  )[0]

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





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





  """simple docstring"""




  def 						snake_case	(					self  ):







   """simple docstring"""
   # clean up the VRAM after each test
   super().tearDown()
   gc.collect()
   torch.cuda.empty_cache()







  def 						snake_case	(					self  ):







   """simple docstring"""
   lowerCamelCase_  				=						load_image(
       "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main" "/shap_e/corgi.png"  )
   lowerCamelCase_  				=						load_numpy(
       "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
       "/shap_e/test_shap_e_img2img_out.npy"  )
   lowerCamelCase_  				=						ShapEImgaImgPipeline.from_pretrained("openai/shap-e-img2img"  )
   lowerCamelCase_  				=						pipe.to(UpperCamelCase  )
   pipe.set_progress_bar_config(disable=UpperCamelCase  )

   lowerCamelCase_  				=						torch.Generator(device=UpperCamelCase  ).manual_seed(0  )

   lowerCamelCase_  				=						pipe(
       UpperCamelCase    ,						generator=UpperCamelCase    ,						guidance_scale=3.0    ,						num_inference_steps=64    ,						frame_size=64    ,						output_type="np"    ,						).images[0]

   assert images.shape == (20, 64, 64, 3)

   assert_mean_pixel_difference(UpperCamelCase    ,						UpperCamelCase  )







'''simple docstring'''

from collections import OrderedDict
from typing import TYPE_CHECKING, Any, Mapping, Optional, Union

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig, OnnxSeqaSeqConfigWithPast
from ...utils import logging


if TYPE_CHECKING:
     from ...feature_extraction_utils import FeatureExtractionMixin
     from ...tokenization_utils_base import PreTrainedTokenizerBase
     from ...utils import TensorType

a_						:       Optional[int]      			=				logging.get_logger(__name__)

a_						:       Optional[int]      			=				{
    """openai/whisper-base""": """https://huggingface.co/openai/whisper-base/resolve/main/config.json""",
}

# fmt: off
a_						:       List[str]      			=				[
    1, 2, 7, 8, 9, 10, 14, 25,
    26, 27, 28, 29, 31, 58, 59, 60, 61, 62,
    63, 90, 91, 92, 93, 357, 366, 438, 532, 685,
    705, 796, 930, 1058, 1220, 1267, 1279, 1303, 1343, 1377,
    1391, 1635, 1782, 1875, 2162, 2361, 2488, 3467, 4008, 4211,
    4600, 4808, 5299, 5855, 6329, 7203, 9609, 9959, 10563, 10786,
    11420, 11709, 11907, 13163, 13697, 13700, 14808, 15306, 16410, 16791,
    17992, 19203, 19510, 20724, 22305, 22935, 27007, 30109, 30420, 33409,
    34949, 40283, 40493, 40549, 47282, 49146, 50257, 50359, 50360, 50361
]
a_						:       Tuple      			=				[
    1, 2, 7, 8, 9, 10, 14, 25,
    26, 27, 28, 29, 31, 58, 59, 60, 61, 62,
    63, 90, 91, 92, 93, 359, 503, 522, 542, 873,
    893, 902, 918, 922, 931, 1350, 1853, 1982, 2460, 2627,
    3246, 3253, 3268, 3536, 3846, 3961, 4183, 4667, 6585, 6647,
    7273, 9061, 9383, 10428, 10929, 11938, 12033, 12331, 12562, 13793,
    14157, 14635, 15265, 15618, 16553, 16604, 18362, 18956, 20075, 21675,
    22520, 26130, 26161, 26435, 28279, 29464, 31650, 32302, 32470, 36865,
    42863, 47425, 49870, 50254, 50258, 50360, 50361, 50362
]





class   snake_case					(					lowercase    ):





  """simple docstring"""




  _lowerCamelCase						=						"whisper"
  _lowerCamelCase						=						["past_key_values"]
  _lowerCamelCase						=						{"num_attention_heads": "encoder_attention_heads", "hidden_size": "d_model"}






  def __init__(					self    ,						UpperCamelCase=5_1865    ,						UpperCamelCase=80    ,						UpperCamelCase=6    ,						UpperCamelCase=4    ,						UpperCamelCase=6    ,						UpperCamelCase=4    ,						UpperCamelCase=1536    ,						UpperCamelCase=1536    ,						UpperCamelCase=0.0    ,						UpperCamelCase=0.0    ,						UpperCamelCase=5_0257    ,						UpperCamelCase=True    ,						UpperCamelCase=True    ,						UpperCamelCase="gelu"    ,						UpperCamelCase=256    ,						UpperCamelCase=0.0    ,						UpperCamelCase=0.0    ,						UpperCamelCase=0.0    ,						UpperCamelCase=0.02    ,						UpperCamelCase=False    ,						UpperCamelCase=1500    ,						UpperCamelCase=448    ,						UpperCamelCase=5_0256    ,						UpperCamelCase=5_0256    ,						UpperCamelCase=5_0256    ,						UpperCamelCase=None    ,						UpperCamelCase=[220, 5_0256]    ,						UpperCamelCase=False    ,						UpperCamelCase=256    ,						UpperCamelCase=False    ,						UpperCamelCase=0.05    ,						UpperCamelCase=10    ,						UpperCamelCase=2    ,						UpperCamelCase=0.0    ,						UpperCamelCase=10    ,						UpperCamelCase=0    ,						UpperCamelCase=7    ,						**UpperCamelCase    ,						):







   """simple docstring"""
   lowerCamelCase_  				=						vocab_size
   lowerCamelCase_  				=						num_mel_bins
   lowerCamelCase_  				=						d_model
   lowerCamelCase_  				=						encoder_layers
   lowerCamelCase_  				=						encoder_attention_heads
   lowerCamelCase_  				=						decoder_layers
   lowerCamelCase_  				=						decoder_attention_heads
   lowerCamelCase_  				=						decoder_ffn_dim
   lowerCamelCase_  				=						encoder_ffn_dim
   lowerCamelCase_  				=						dropout
   lowerCamelCase_  				=						attention_dropout
   lowerCamelCase_  				=						activation_dropout
   lowerCamelCase_  				=						activation_function
   lowerCamelCase_  				=						init_std
   lowerCamelCase_  				=						encoder_layerdrop
   lowerCamelCase_  				=						decoder_layerdrop
   lowerCamelCase_  				=						use_cache
   lowerCamelCase_  				=						encoder_layers
   lowerCamelCase_  				=						scale_embedding  # scale factor will be sqrt(d_model) if True
   lowerCamelCase_  				=						max_source_positions
   lowerCamelCase_  				=						max_target_positions

   # Audio Classification-specific parameters. Feel free to ignore for other classes.
   lowerCamelCase_  				=						classifier_proj_size
   lowerCamelCase_  				=						use_weighted_layer_sum

   # fine-tuning config parameters for SpecAugment: https://arxiv.org/abs/1904.08779
   lowerCamelCase_  				=						apply_spec_augment
   lowerCamelCase_  				=						mask_time_prob
   lowerCamelCase_  				=						mask_time_length
   lowerCamelCase_  				=						mask_time_min_masks
   lowerCamelCase_  				=						mask_feature_prob
   lowerCamelCase_  				=						mask_feature_length
   lowerCamelCase_  				=						mask_feature_min_masks

   lowerCamelCase_  				=						median_filter_width

   super().__init__(
       pad_token_id=UpperCamelCase    ,						bos_token_id=UpperCamelCase    ,						eos_token_id=UpperCamelCase    ,						is_encoder_decoder=UpperCamelCase    ,						decoder_start_token_id=UpperCamelCase    ,						suppress_tokens=UpperCamelCase    ,						begin_suppress_tokens=UpperCamelCase    ,						**UpperCamelCase    ,						)





class   snake_case					(					lowercase    ):





  """simple docstring"""




  @property
  def 						snake_case	(					self  ):







   """simple docstring"""
   lowerCamelCase_  				=						OrderedDict(
       [
           ("input_features", {0: "batch", 1: "feature_size", 2: "encoder_sequence"}),
       ]  )
   if self.use_past:
    lowerCamelCase_  				=						{0: "batch"}
   else:
    lowerCamelCase_  				=						{0: "batch", 1: "decoder_sequence"}

   if self.use_past:
    self.fill_with_past_key_values_(UpperCamelCase    ,						direction="inputs"  )

   return common_inputs






  def 						snake_case	(					self    ,						UpperCamelCase    ,						UpperCamelCase = -1    ,						UpperCamelCase = -1    ,						UpperCamelCase = False    ,						UpperCamelCase = None    ,						UpperCamelCase = 2_2050    ,						UpperCamelCase = 5.0    ,						UpperCamelCase = 220    ,						):







   """simple docstring"""
   lowerCamelCase_  				=						OrderedDict()
   lowerCamelCase_  				=						OnnxConfig.generate_dummy_inputs(
       self    ,						preprocessor=preprocessor.feature_extractor    ,						batch_size=UpperCamelCase    ,						framework=UpperCamelCase    ,						sampling_rate=UpperCamelCase    ,						time_duration=UpperCamelCase    ,						frequency=UpperCamelCase    ,						)
   lowerCamelCase_  				=						encoder_inputs["input_features"].shape[2]
   lowerCamelCase_  				=						encoder_sequence_length // 2 if self.use_past else seq_length

   lowerCamelCase_  				=						super().generate_dummy_inputs(
       preprocessor.tokenizer    ,						UpperCamelCase    ,						UpperCamelCase    ,						UpperCamelCase    ,						UpperCamelCase  )

   lowerCamelCase_  				=						encoder_inputs.pop("input_features"  )
   lowerCamelCase_  				=						decoder_inputs.pop("decoder_input_ids"  )

   if "past_key_values" in decoder_inputs:
    lowerCamelCase_  				=						decoder_inputs.pop("past_key_values"  )

   return dummy_inputs







  @property
  def 						snake_case	(					self  ):







   """simple docstring"""
   return 1e-3



