






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     (			a      ,     unittest.TestCase ):





				"""simple docstring"""







				UpperCamelCase__ :      str			 =ShapEImgaImgPipeline
				UpperCamelCase__ :      Optional[int]			 =["""image"""]
				UpperCamelCase__ :      Dict			 =["""image"""]
				UpperCamelCase__ :      Optional[int]			 =[
				    """num_images_per_prompt""",
				    """num_inference_steps""",
				    """generator""",
				    """latents""",
				    """guidance_scale""",
				    """frame_size""",
				    """output_type""",
				    """return_dict""",
				]
				UpperCamelCase__ :      int			 =False


				@property
				def       __lowercase							( self    ):




									"""simple docstring"""

									return 32


				@property
				def       __lowercase							( self    ):




									"""simple docstring"""

									return 32


				@property
				def       __lowercase							( self    ):




									"""simple docstring"""

									return self.time_input_dim * 4


				@property
				def       __lowercase							( self    ):




									"""simple docstring"""

									return 8


				@property
				def       __lowercase							( self    ):




									"""simple docstring"""

									torch.manual_seed(0    )
									__UpperCamelCase      :					Optional[int]       		=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      :					List[Any]       		=CLIPVisionModel(lowerCamelCase__    )
									return model


				@property
				def       __lowercase							( self    ):




									"""simple docstring"""

									__UpperCamelCase      :					List[Any]       		=CLIPImageProcessor(
									    crop_size=224							,  do_center_crop=lowerCamelCase__							,  do_normalize=lowerCamelCase__							,  do_resize=lowerCamelCase__							,  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       __lowercase							( 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      :					Tuple       		=PriorTransformer(**lowerCamelCase__    )
									return model


				@property
				def       __lowercase							( self    ):




									"""simple docstring"""

									torch.manual_seed(0    )

									__UpperCamelCase      :					Dict       		={
									    '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      :					List[Any]       		=ShapERenderer(**lowerCamelCase__    )
									return model


				def       __lowercase							( self    ):




									"""simple docstring"""

									__UpperCamelCase      :					Any       		=self.dummy_prior
									__UpperCamelCase      :					Optional[int]       		=self.dummy_image_encoder
									__UpperCamelCase      :					Dict       		=self.dummy_image_processor
									__UpperCamelCase      :					List[str]       		=self.dummy_renderer

									__UpperCamelCase      :					Union[str, 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      :					List[Any]       		={
									    'prior': prior,
									    'image_encoder': image_encoder,
									    'image_processor': image_processor,
									    'renderer': renderer,
									    'scheduler': scheduler,
									}

									return components


				def       __lowercase							( self							,  lowerCamelCase__							,  lowerCamelCase__=0    ):




									"""simple docstring"""

									__UpperCamelCase      :					Optional[Any]       		=floats_tensor((1, 3, 64, 64)							,  rng=random.Random(lowerCamelCase__    )    ).to(lowerCamelCase__    )

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


				def       __lowercase							( self    ):




									"""simple docstring"""

									__UpperCamelCase      :					Union[str, Any]       		='cpu'

									__UpperCamelCase      :					Any       		=self.get_dummy_components()

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

									pipe.set_progress_bar_config(disable=lowerCamelCase__    )

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

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

									__UpperCamelCase      :					Optional[int]       		=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       __lowercase							( self    ):




									"""simple docstring"""

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


				def       __lowercase							( self    ):




									"""simple docstring"""

									__UpperCamelCase      :					Tuple       		=torch_device == 'cpu'
									__UpperCamelCase      :					Tuple       		=True
									self._test_inference_batch_single_identical(
									    batch_size=2							,  test_max_difference=lowerCamelCase__							,  relax_max_difference=lowerCamelCase__							,  )







				def       __lowercase							( self    ):




									"""simple docstring"""

									__UpperCamelCase      :					Dict       		=self.get_dummy_components()
									__UpperCamelCase      :					Dict       		=self.pipeline_class(**lowerCamelCase__    )
									__UpperCamelCase      :					Dict       		=pipe.to(lowerCamelCase__    )
									pipe.set_progress_bar_config(disable=lowerCamelCase__    )

									__UpperCamelCase      :					Any       		=1
									__UpperCamelCase      :					Optional[Any]       		=2

									__UpperCamelCase      :					List[str]       		=self.get_dummy_inputs(lowerCamelCase__    )

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

									__UpperCamelCase      :					Union[str, Any]       		=pipe(**lowerCamelCase__							,  num_images_per_prompt=lowerCamelCase__    )[0]

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




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





				"""simple docstring"""







				def       __lowercase							( self    ):




									"""simple docstring"""

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







				def       __lowercase							( self    ):




									"""simple docstring"""

									__UpperCamelCase      :					Optional[Any]       		=load_image(
									    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/shap_e/corgi.png'    )
									__UpperCamelCase      :					Optional[Any]       		=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(lowerCamelCase__    )
									pipe.set_progress_bar_config(disable=lowerCamelCase__    )

									__UpperCamelCase      :					Optional[Any]       		=torch.Generator(device=lowerCamelCase__    ).manual_seed(0    )

									__UpperCamelCase      :					Union[str, Any]       		=pipe(
									    lowerCamelCase__							,  generator=lowerCamelCase__							,  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(lowerCamelCase__							,  lowerCamelCase__    )








import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
     import torch

if is_vision_available():
     from PIL import Image

     from transformers import MobileViTImageProcessor







class 				__lowerCAmelCase       (    unittest.TestCase):







      def __init__(    self		,      lowerCAmelCase__		,      lowerCAmelCase__=7		,      lowerCAmelCase__=3		,      lowerCAmelCase__=1_8		,      lowerCAmelCase__=3_0		,      lowerCAmelCase__=4_0_0		,      lowerCAmelCase__=True		,      lowerCAmelCase__=None		,      lowerCAmelCase__=True		,      lowerCAmelCase__=None		,      lowerCAmelCase__=True		,      )   ->						Optional[Any]:



        '''simple docstring'''




        a__	:					Union[str, Any]										=size if size is not None else {"shortest_edge": 2_0}
        a__	:					List[str]										=crop_size if crop_size is not None else {"height": 1_8, "width": 1_8}
        a__	:					Tuple										=parent
        a__	:					Union[str, Any]										=batch_size
        a__	:					List[str]										=num_channels
        a__	:					List[Any]										=image_size
        a__	:					str										=min_resolution
        a__	:					Optional[int]										=max_resolution
        a__	:					Tuple										=do_resize
        a__	:					Union[str, Any]										=size
        a__	:					List[Any]										=do_center_crop
        a__	:					List[str]										=crop_size
        a__	:					Optional[int]										=do_flip_channel_order







      def    _lowercase  (    self							)   ->						Optional[int]:



        '''simple docstring'''




        return {
            "do_resize": self.do_resize,
            "size": self.size,
            "do_center_crop": self.do_center_crop,
            "crop_size": self.crop_size,
            "do_flip_channel_order": self.do_flip_channel_order,
        }







@require_torch
@require_vision
class 				__lowerCAmelCase       (    UpperCamelCase__						,				unittest.TestCase):
      _lowercase				:					int						=			MobileViTImageProcessor if is_vision_available() else None







      def    _lowercase  (    self							)   ->						Optional[Any]:



        '''simple docstring'''




        a__	:					Tuple										=MobileViTImageProcessingTester(self							)







      @property
      def    _lowercase  (    self							)   ->						List[str]:



        '''simple docstring'''




        return self.image_processor_tester.prepare_image_processor_dict()







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



        '''simple docstring'''




        a__	:					str										=self.image_processing_class(**self.image_processor_dict							)
        self.assertTrue(hasattr(lowerCAmelCase__		,      "do_resize"							)							)
        self.assertTrue(hasattr(lowerCAmelCase__		,      "size"							)							)
        self.assertTrue(hasattr(lowerCAmelCase__		,      "do_center_crop"							)							)
        self.assertTrue(hasattr(lowerCAmelCase__		,      "center_crop"							)							)
        self.assertTrue(hasattr(lowerCAmelCase__		,      "do_flip_channel_order"							)							)







      def    _lowercase  (    self							)   ->						Optional[int]:



        '''simple docstring'''




        a__	:					List[Any]										=self.image_processing_class.from_dict(self.image_processor_dict							)
        self.assertEqual(image_processor.size		,      {"shortest_edge": 2_0}							)
        self.assertEqual(image_processor.crop_size		,      {"height": 1_8, "width": 1_8}							)

        a__	:					Union[str, Any]										=self.image_processing_class.from_dict(self.image_processor_dict		,      size=4_2		,      crop_size=8_4							)
        self.assertEqual(image_processor.size		,      {"shortest_edge": 4_2}							)
        self.assertEqual(image_processor.crop_size		,      {"height": 8_4, "width": 8_4}							)







      def    _lowercase  (    self							)   ->						Optional[Any]:



        '''simple docstring'''




        pass







      def    _lowercase  (    self							)   ->						Tuple:



        '''simple docstring'''




        a__	:					List[str]										=self.image_processing_class(**self.image_processor_dict							)
        # create random PIL images
        a__	:					Any										=prepare_image_inputs(self.image_processor_tester		,      equal_resolution=lowerCAmelCase__							)
        for image in image_inputs:
          self.assertIsInstance(lowerCAmelCase__		,      Image.Image							)

        # Test not batched input
        a__	:					Tuple										=image_processing(image_inputs[0]		,      return_tensors="pt"							).pixel_values
        self.assertEqual(
            encoded_images.shape		,      (
                1,
                self.image_processor_tester.num_channels,
                self.image_processor_tester.crop_size["height"],
                self.image_processor_tester.crop_size["width"],
            )		,      )

        # Test batched
        a__	:					List[Any]										=image_processing(lowerCAmelCase__		,      return_tensors="pt"							).pixel_values
        self.assertEqual(
            encoded_images.shape		,      (
                self.image_processor_tester.batch_size,
                self.image_processor_tester.num_channels,
                self.image_processor_tester.crop_size["height"],
                self.image_processor_tester.crop_size["width"],
            )		,      )







      def    _lowercase  (    self							)   ->						Any:



        '''simple docstring'''




        a__	:					Optional[Any]										=self.image_processing_class(**self.image_processor_dict							)
        # create random numpy tensors
        a__	:					List[Any]										=prepare_image_inputs(self.image_processor_tester		,      equal_resolution=lowerCAmelCase__		,      numpify=lowerCAmelCase__							)
        for image in image_inputs:
          self.assertIsInstance(lowerCAmelCase__		,      np.ndarray							)

        # Test not batched input
        a__	:					Tuple										=image_processing(image_inputs[0]		,      return_tensors="pt"							).pixel_values
        self.assertEqual(
            encoded_images.shape		,      (
                1,
                self.image_processor_tester.num_channels,
                self.image_processor_tester.crop_size["height"],
                self.image_processor_tester.crop_size["width"],
            )		,      )

        # Test batched
        a__	:					int										=image_processing(lowerCAmelCase__		,      return_tensors="pt"							).pixel_values
        self.assertEqual(
            encoded_images.shape		,      (
                self.image_processor_tester.batch_size,
                self.image_processor_tester.num_channels,
                self.image_processor_tester.crop_size["height"],
                self.image_processor_tester.crop_size["width"],
            )		,      )







      def    _lowercase  (    self							)   ->						Optional[Any]:



        '''simple docstring'''




        a__	:					int										=self.image_processing_class(**self.image_processor_dict							)
        # create random PyTorch tensors
        a__	:					Tuple										=prepare_image_inputs(self.image_processor_tester		,      equal_resolution=lowerCAmelCase__		,      torchify=lowerCAmelCase__							)
        for image in image_inputs:
          self.assertIsInstance(lowerCAmelCase__		,      torch.Tensor							)

        # Test not batched input
        a__	:					List[str]										=image_processing(image_inputs[0]		,      return_tensors="pt"							).pixel_values
        self.assertEqual(
            encoded_images.shape		,      (
                1,
                self.image_processor_tester.num_channels,
                self.image_processor_tester.crop_size["height"],
                self.image_processor_tester.crop_size["width"],
            )		,      )

        # Test batched
        a__	:					List[str]										=image_processing(lowerCAmelCase__		,      return_tensors="pt"							).pixel_values
        self.assertEqual(
            encoded_images.shape		,      (
                self.image_processor_tester.batch_size,
                self.image_processor_tester.num_channels,
                self.image_processor_tester.crop_size["height"],
                self.image_processor_tester.crop_size["width"],
            )		,      )






