





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    A__  (			__snake_case			,  unittest.TestCase     ):
      _UpperCAmelCase      :str		       =  ShapEImgaImgPipeline
      _UpperCAmelCase      :int		       =  ['image']
      _UpperCAmelCase      :Optional[Any]		       =  ['image']
      _UpperCAmelCase      :Optional[Any]		       =  [
          'num_images_per_prompt',
          'num_inference_steps',
          'generator',
          'latents',
          'guidance_scale',
          'frame_size',
          'output_type',
          'return_dict',
      ]
      _UpperCAmelCase      :Optional[Any]		       =  False





      @property
      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       return 32





      @property
      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       return 32





      @property
      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       return self.time_input_dim * 4





      @property
      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       return 8





      @property
      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       torch.manual_seed(0  )
       UpperCamelCase      :   List[str]			      =  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			,				)

       UpperCamelCase      :   Optional[int]			      =  CLIPVisionModel(A_  )
       return model





      @property
      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       UpperCamelCase      :   List[str]			      =  CLIPImageProcessor(
           crop_size=224			,				do_center_crop=A_			,				do_normalize=A_			,				do_resize=A_			,				image_mean=[0.48_14_54_66, 0.4_57_82_75, 0.40_82_10_73]			,				image_std=[0.26_86_29_54, 0.26_13_02_58, 0.27_57_77_11]			,				resample=3			,				size=224			,				)

       return image_processor





      @property
      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       torch.manual_seed(0  )

       UpperCamelCase      :   Tuple			      =  {
           "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,
       }

       UpperCamelCase      :   List[str]			      =  PriorTransformer(**A_  )
       return model





      @property
      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       torch.manual_seed(0  )

       UpperCamelCase      :   str			      =  {
           "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      :   Optional[Any]			      =  ShapERenderer(**A_  )
       return model





      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       UpperCamelCase      :   str			      =  self.dummy_prior
       UpperCamelCase      :   str			      =  self.dummy_image_encoder
       UpperCamelCase      :   str			      =  self.dummy_image_processor
       UpperCamelCase      :   List[Any]			      =  self.dummy_renderer

       UpperCamelCase      :   int			      =  HeunDiscreteScheduler(
           beta_schedule="exp"			,				num_train_timesteps=1024			,				prediction_type="sample"			,				use_karras_sigmas=A_			,				clip_sample=A_			,				clip_sample_range=1.0			,				)
       UpperCamelCase      :   Union[str, Any]			      =  {
           "prior": prior,
           "image_encoder": image_encoder,
           "image_processor": image_processor,
           "renderer": renderer,
           "scheduler": scheduler,
       }

       return components





      def 			__UpperCamelCase(					self			,				A_			,				A_=0  ):
       '''simple docstring'''




       UpperCamelCase      :   Optional[int]			      =  floats_tensor((1, 3, 64, 64)			,				rng=random.Random(A_  )  ).to(A_  )

       if str(A_  ).startswith("mps"  ):
        UpperCamelCase      :   Union[str, Any]			      =  torch.manual_seed(A_  )
       else:
        UpperCamelCase      :   List[str]			      =  torch.Generator(device=A_  ).manual_seed(A_  )
       UpperCamelCase      :   int			      =  {
           "image": input_image,
           "generator": generator,
           "num_inference_steps": 1,
           "frame_size": 32,
           "output_type": "np",
       }
       return inputs





      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       UpperCamelCase      :   List[str]			      =  "cpu"

       UpperCamelCase      :   Dict			      =  self.get_dummy_components()

       UpperCamelCase      :   int			      =  self.pipeline_class(**A_  )
       UpperCamelCase      :   Union[str, Any]			      =  pipe.to(A_  )

       pipe.set_progress_bar_config(disable=A_  )

       UpperCamelCase      :   Tuple			      =  pipe(**self.get_dummy_inputs(A_  )  )
       UpperCamelCase      :   Union[str, Any]			      =  output.images[0]
       UpperCamelCase      :   Dict			      =  image[0, -3:, -3:, -1]

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

       UpperCamelCase      :   Tuple			      =  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 			__UpperCamelCase(					self  ):
       '''simple docstring'''




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





      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       UpperCamelCase      :   Any			      =  torch_device == "cpu"
       UpperCamelCase      :   Optional[int]			      =  True
       self._test_inference_batch_single_identical(
           batch_size=2			,				test_max_difference=A_			,				relax_max_difference=A_			,				)





      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       UpperCamelCase      :   Optional[Any]			      =  self.get_dummy_components()
       UpperCamelCase      :   str			      =  self.pipeline_class(**A_  )
       UpperCamelCase      :   List[Any]			      =  pipe.to(A_  )
       pipe.set_progress_bar_config(disable=A_  )

       UpperCamelCase      :   Any			      =  1
       UpperCamelCase      :   int			      =  2

       UpperCamelCase      :   str			      =  self.get_dummy_inputs(A_  )

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

       UpperCamelCase      :   Optional[int]			      =  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 			__UpperCamelCase(					self  ):
       '''simple docstring'''




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





      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       UpperCamelCase      :   List[Any]			      =  load_image(
           "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main" "/shap_e/corgi.png"  )
       UpperCamelCase      :   Optional[int]			      =  load_numpy(
           "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
           "/shap_e/test_shap_e_img2img_out.npy"  )
       UpperCamelCase      :   List[str]			      =  ShapEImgaImgPipeline.from_pretrained("openai/shap-e-img2img"  )
       UpperCamelCase      :   Any			      =  pipe.to(A_  )
       pipe.set_progress_bar_config(disable=A_  )

       UpperCamelCase      :   Any			      =  torch.Generator(device=A_  ).manual_seed(0  )

       UpperCamelCase      :   Dict			      =  pipe(
           A_			,				generator=A_			,				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(A_			,				A_  )







import json
import os
import tempfile

from transformers.testing_utils import check_json_file_has_correct_format



class    A__  :
      _UpperCAmelCase      :Union[str, Any]		       =  None





      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       UpperCamelCase      :   int			      =  self.feature_extraction_class(**self.feat_extract_dict  )
       UpperCamelCase      :   Union[str, Any]			      =  json.loads(feat_extract.to_json_string()  )
       for key, value in self.feat_extract_dict.items():
        self.assertEqual(obj[key]			,				A_  )





      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       UpperCamelCase      :   str			      =  self.feature_extraction_class(**self.feat_extract_dict  )

       with tempfile.TemporaryDirectory() as tmpdirname:
        UpperCamelCase      :   List[Any]			      =  os.path.join(A_			,				"feat_extract.json"  )
        feat_extract_first.to_json_file(A_  )
        UpperCamelCase      :   str			      =  self.feature_extraction_class.from_json_file(A_  )

       self.assertEqual(feat_extract_second.to_dict()			,				feat_extract_first.to_dict()  )





      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       UpperCamelCase      :   Union[str, Any]			      =  self.feature_extraction_class(**self.feat_extract_dict  )

       with tempfile.TemporaryDirectory() as tmpdirname:
        UpperCamelCase      :   int			      =  feat_extract_first.save_pretrained(A_  )[0]
        check_json_file_has_correct_format(A_  )
        UpperCamelCase      :   Optional[Any]			      =  self.feature_extraction_class.from_pretrained(A_  )

       self.assertEqual(feat_extract_second.to_dict()			,				feat_extract_first.to_dict()  )





      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       UpperCamelCase      :   Any			      =  self.feature_extraction_class()
       self.assertIsNotNone(A_  )
