





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

     '''simple docstring'''


     a		:							Tuple     	=	ShapEPipeline
     a		:							str     	=	["prompt"]
     a		:							Optional[int]     	=	["prompt"]
     a		:							Optional[Any]     	=	[
         "num_images_per_prompt",
         "num_inference_steps",
         "generator",
         "latents",
         "guidance_scale",
         "frame_size",
         "output_type",
         "return_dict",
     ]
     a		:							Union[str, Any]     	=	False




     @property
     def    UpperCamelCase__						(					self							)				->   str:






         """simple docstring"""
         return 32




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






         """simple docstring"""
         return 32




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






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




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






         """simple docstring"""
         return 8




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






         """simple docstring"""
         UpperCamelCase__							:       List[Any]      =   CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''							)
         return tokenizer




     @property
     def    UpperCamelCase__						(					self							)				->   int:






         """simple docstring"""
         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=37,	layer_norm_eps=1E-05,	num_attention_heads=4,	num_hidden_layers=5,	pad_token_id=1,	vocab_size=1000,	)
         return CLIPTextModelWithProjection(__magic_name__							)




     @property
     def    UpperCamelCase__						(					self							)				->   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__							:       int      =   PriorTransformer(**__magic_name__							)
         return model




     @property
     def    UpperCamelCase__						(					self							)				->   str:






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

         UpperCamelCase__							:       Tuple      =   {
             '''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__							:       Union[str, Any]      =   ShapERenderer(**__magic_name__							)
         return model




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






         """simple docstring"""
         UpperCamelCase__							:       int      =   self.dummy_prior
         UpperCamelCase__							:       List[Any]      =   self.dummy_text_encoder
         UpperCamelCase__							:       Optional[int]      =   self.dummy_tokenizer
         UpperCamelCase__							:       Tuple      =   self.dummy_renderer

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

         return components




     def    UpperCamelCase__						(					self,	__magic_name__,	__magic_name__=0							)				->   Optional[Any]:






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




     def    UpperCamelCase__						(					self							)				->   Union[str, Any]:






         """simple docstring"""
         UpperCamelCase__							:       str      =   '''cpu'''

         UpperCamelCase__							:       Optional[Any]      =   self.get_dummy_components()

         UpperCamelCase__							:       Tuple      =   self.pipeline_class(**__magic_name__							)
         UpperCamelCase__							:       int      =   pipe.to(__magic_name__							)

         pipe.set_progress_bar_config(disable=__magic_name__							)

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

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

         UpperCamelCase__							:       Dict      =   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							)				->   str:






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




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






         """simple docstring"""
         UpperCamelCase__							:       int      =   torch_device == '''cpu'''
         UpperCamelCase__							:       Optional[int]      =   True

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




     def    UpperCamelCase__						(					self							)				->   List[Any]:






         """simple docstring"""
         UpperCamelCase__							:       Any      =   self.get_dummy_components()
         UpperCamelCase__							:       int      =   self.pipeline_class(**__magic_name__							)
         UpperCamelCase__							:       Tuple      =   pipe.to(__magic_name__							)
         pipe.set_progress_bar_config(disable=__magic_name__							)

         UpperCamelCase__							:       List[Any]      =   1
         UpperCamelCase__							:       Optional[Any]      =   2

         UpperCamelCase__							:       List[str]      =   self.get_dummy_inputs(__magic_name__							)

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

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

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






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

     '''simple docstring'''


     def    UpperCamelCase__						(					self							)				->   Tuple:






         """simple docstring"""
         super().tearDown()
         gc.collect()
         torch.cuda.empty_cache()




     def    UpperCamelCase__						(					self							)				->   Tuple:






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

         UpperCamelCase__							:       Union[str, Any]      =   torch.Generator(device=__magic_name__							).manual_seed(0							)

         UpperCamelCase__							:       Union[str, Any]      =   pipe(
             '''a shark''',	generator=__magic_name__,	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(__magic_name__,	__magic_name__							)








import inspect
import unittest
from math import floor

from transformers import CvtConfig
from transformers.file_utils import cached_property, is_torch_available, is_vision_available
from transformers.testing_utils import require_torch, require_vision, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
  import torch

  from transformers import CvtForImageClassification, CvtModel
  from transformers.models.cvt.modeling_cvt import CVT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
  from PIL import Image

  from transformers import AutoImageProcessor






class 					lowercase__ (			__lowerCamelCase       ):

   '''simple docstring'''


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






       """simple docstring"""
       UpperCamelCase__							:       Optional[Any]      =   self.config_class(**self.inputs_dict							)
       self.parent.assertTrue(hasattr(__magic_name__,	'''embed_dim'''							)							)
       self.parent.assertTrue(hasattr(__magic_name__,	'''num_heads'''							)							)






class 					lowercase__ :

   '''simple docstring'''


   def __init__(					self,	__magic_name__,	__magic_name__=13,	__magic_name__=64,	__magic_name__=3,	__magic_name__=[16, 48, 96],	__magic_name__=[1, 3, 6],	__magic_name__=[1, 2, 10],	__magic_name__=[7, 3, 3],	__magic_name__=[4, 2, 2],	__magic_name__=[2, 1, 1],	__magic_name__=[2, 2, 2],	__magic_name__=[False, False, True],	__magic_name__=[0.0, 0.0, 0.0],	__magic_name__=0.02,	__magic_name__=1E-12,	__magic_name__=True,	__magic_name__=True,	__magic_name__=2,	)				->   int:






       """simple docstring"""
       UpperCamelCase__							:       Optional[int]      =   parent
       UpperCamelCase__							:       Optional[Any]      =   batch_size
       UpperCamelCase__							:       Dict      =   image_size
       UpperCamelCase__							:       Optional[Any]      =   patch_sizes
       UpperCamelCase__							:       List[str]      =   patch_stride
       UpperCamelCase__							:       Tuple      =   patch_padding
       UpperCamelCase__							:       Dict      =   is_training
       UpperCamelCase__							:       Optional[int]      =   use_labels
       UpperCamelCase__							:       Union[str, Any]      =   num_labels
       UpperCamelCase__							:       List[Any]      =   num_channels
       UpperCamelCase__							:       Optional[Any]      =   embed_dim
       UpperCamelCase__							:       List[str]      =   num_heads
       UpperCamelCase__							:       Any      =   stride_kv
       UpperCamelCase__							:       Any      =   depth
       UpperCamelCase__							:       Tuple      =   cls_token
       UpperCamelCase__							:       List[Any]      =   attention_drop_rate
       UpperCamelCase__							:       Any      =   initializer_range
       UpperCamelCase__							:       str      =   layer_norm_eps




   def    UpperCamelCase__						(					self							)				->   Any:






       """simple docstring"""
       UpperCamelCase__							:       Optional[int]      =   floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]							)

       UpperCamelCase__							:       int      =   None
       if self.use_labels:
           UpperCamelCase__							:       Optional[int]      =   ids_tensor([self.batch_size],	self.num_labels							)

       UpperCamelCase__							:       str      =   self.get_config()
       return config, pixel_values, labels




   def    UpperCamelCase__						(					self							)				->   int:






       """simple docstring"""
       return CvtConfig(
           image_size=self.image_size,	num_labels=self.num_labels,	num_channels=self.num_channels,	embed_dim=self.embed_dim,	num_heads=self.num_heads,	patch_sizes=self.patch_sizes,	patch_padding=self.patch_padding,	patch_stride=self.patch_stride,	stride_kv=self.stride_kv,	depth=self.depth,	cls_token=self.cls_token,	attention_drop_rate=self.attention_drop_rate,	initializer_range=self.initializer_range,	)




   def    UpperCamelCase__						(					self,	__magic_name__,	__magic_name__,	__magic_name__							)				->   Optional[Any]:






       """simple docstring"""
       UpperCamelCase__							:       Optional[Any]      =   CvtModel(config=__magic_name__							)
       model.to(__magic_name__							)
       model.eval()
       UpperCamelCase__							:       Optional[int]      =   model(__magic_name__							)
       UpperCamelCase__							:       List[str]      =   (self.image_size, self.image_size)
       UpperCamelCase__     ,UpperCamelCase__							:       Tuple      =   image_size[0], image_size[1]
       for i in range(len(self.depth							)							):
           UpperCamelCase__							:       Optional[int]      =   floor(((height + 2 * self.patch_padding[i] - self.patch_sizes[i]) / self.patch_stride[i]) + 1							)
           UpperCamelCase__							:       int      =   floor(((width + 2 * self.patch_padding[i] - self.patch_sizes[i]) / self.patch_stride[i]) + 1							)
       self.parent.assertEqual(result.last_hidden_state.shape,	(self.batch_size, self.embed_dim[-1], height, width)							)




   def    UpperCamelCase__						(					self,	__magic_name__,	__magic_name__,	__magic_name__							)				->   List[str]:






       """simple docstring"""
       UpperCamelCase__							:       Tuple      =   self.num_labels
       UpperCamelCase__							:       str      =   CvtForImageClassification(__magic_name__							)
       model.to(__magic_name__							)
       model.eval()
       UpperCamelCase__							:       Any      =   model(__magic_name__,	labels=__magic_name__							)
       self.parent.assertEqual(result.logits.shape,	(self.batch_size, self.num_labels)							)




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






       """simple docstring"""
       UpperCamelCase__							:       int      =   self.prepare_config_and_inputs()
       UpperCamelCase__     ,UpperCamelCase__     ,UpperCamelCase__							:       Optional[int]      =   config_and_inputs
       UpperCamelCase__							:       List[Any]      =   {'''pixel_values''': pixel_values}
       return config, inputs_dict






@require_torch
class 					lowercase__ (			__lowerCamelCase    ,       __lowerCamelCase    ,       unittest.TestCase       ):

   '''simple docstring'''


   a		:							List[Any]     	=	(CvtModel, CvtForImageClassification) if is_torch_available() else ()
   a		:							Any     	=	(
       {"feature-extraction": CvtModel, "image-classification": CvtForImageClassification}
       if is_torch_available()
       else {}
   )

   a		:							List[str]     	=	False
   a		:							int     	=	False
   a		:							Tuple     	=	False
   a		:							int     	=	False
   a		:							Tuple     	=	False




   def    UpperCamelCase__						(					self							)				->   str:






       """simple docstring"""
       UpperCamelCase__							:       Dict      =   CvtModelTester(self							)
       UpperCamelCase__							:       List[Any]      =   ConfigTester(self,	config_class=__magic_name__,	has_text_modality=__magic_name__,	hidden_size=37							)




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






       """simple docstring"""
       self.create_and_test_config_common_properties()
       self.config_tester.create_and_test_config_to_json_string()
       self.config_tester.create_and_test_config_to_json_file()
       self.config_tester.create_and_test_config_from_and_save_pretrained()
       self.config_tester.create_and_test_config_with_num_labels()
       self.config_tester.check_config_can_be_init_without_params()
       self.config_tester.check_config_arguments_init()




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






       """simple docstring"""
       return




   @unittest.skip(reason='''Cvt does not output attentions'''							)
   def    UpperCamelCase__						(					self							)				->   Dict:






       """simple docstring"""
       pass




   @unittest.skip(reason='''Cvt does not use inputs_embeds'''							)
   def    UpperCamelCase__						(					self							)				->   Tuple:






       """simple docstring"""
       pass




   @unittest.skip(reason='''Cvt does not support input and output embeddings'''							)
   def    UpperCamelCase__						(					self							)				->   Dict:






       """simple docstring"""
       pass




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






       """simple docstring"""
       UpperCamelCase__     ,UpperCamelCase__							:       Optional[int]      =   self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
           UpperCamelCase__							:       List[Any]      =   model_class(__magic_name__							)
           UpperCamelCase__							:       List[Any]      =   inspect.signature(model.forward							)
           # signature.parameters is an OrderedDict => so arg_names order is deterministic
           UpperCamelCase__							:       Optional[int]      =   [*signature.parameters.keys()]

           UpperCamelCase__							:       Tuple      =   ['''pixel_values''']
           self.assertListEqual(arg_names[:1],	__magic_name__							)




   def    UpperCamelCase__						(					self							)				->   Tuple:






       """simple docstring"""
       UpperCamelCase__							:       Union[str, Any]      =   self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*__magic_name__							)




   def    UpperCamelCase__						(					self							)				->   Dict:






       """simple docstring"""
       def check_hidden_states_output(__magic_name__,	__magic_name__,	__magic_name__							):
           UpperCamelCase__							:       str      =   model_class(__magic_name__							)
           model.to(__magic_name__							)
           model.eval()

           with torch.no_grad():
               UpperCamelCase__							:       List[Any]      =   model(**self._prepare_for_class(__magic_name__,	__magic_name__							)							)

           UpperCamelCase__							:       str      =   outputs.hidden_states

           UpperCamelCase__							:       Dict      =   len(self.model_tester.depth							)
           self.assertEqual(len(__magic_name__							),	__magic_name__							)

           # verify the first hidden states (first block)
           self.assertListEqual(
               list(hidden_states[0].shape[-3:]							),	[
                   self.model_tester.embed_dim[0],
                   self.model_tester.image_size // 4,
                   self.model_tester.image_size // 4,
               ],	)

       UpperCamelCase__     ,UpperCamelCase__							:       List[str]      =   self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
           UpperCamelCase__							:       Optional[int]      =   True
           check_hidden_states_output(__magic_name__,	__magic_name__,	__magic_name__							)

           # check that output_hidden_states also work using config
           del inputs_dict["output_hidden_states"]
           UpperCamelCase__							:       int      =   True

           check_hidden_states_output(__magic_name__,	__magic_name__,	__magic_name__							)




   def    UpperCamelCase__						(					self							)				->   List[Any]:






       """simple docstring"""
       UpperCamelCase__							:       Optional[int]      =   self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_image_classification(*__magic_name__							)




   @unittest.skip('''Will be fixed soon by reducing the size of the model used for common tests.'''							)
   def    UpperCamelCase__						(					self							)				->   Optional[Any]:






       """simple docstring"""
       pass




   @slow
   def    UpperCamelCase__						(					self							)				->   Tuple:






       """simple docstring"""
       for model_name in CVT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
           UpperCamelCase__							:       Union[str, Any]      =   CvtModel.from_pretrained(__magic_name__							)
           self.assertIsNotNone(__magic_name__							)




def 	lowerCAmelCase_					(						)   ->			int:
    UpperCamelCase__							:       Tuple      =   Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''   )
    return image






@require_torch
@require_vision
class 					lowercase__ (			unittest.TestCase       ):

   '''simple docstring'''


   @cached_property
   def    UpperCamelCase__						(					self							)				->   Any:






       """simple docstring"""
       return AutoImageProcessor.from_pretrained(CVT_PRETRAINED_MODEL_ARCHIVE_LIST[0]							)




   @slow
   def    UpperCamelCase__						(					self							)				->   Dict:






       """simple docstring"""
       UpperCamelCase__							:       Optional[Any]      =   CvtForImageClassification.from_pretrained(CVT_PRETRAINED_MODEL_ARCHIVE_LIST[0]							).to(__magic_name__							)

       UpperCamelCase__							:       Union[str, Any]      =   self.default_image_processor
       UpperCamelCase__							:       Any      =   prepare_img()
       UpperCamelCase__							:       List[str]      =   image_processor(images=__magic_name__,	return_tensors='''pt'''							).to(__magic_name__							)

       # forward pass
       with torch.no_grad():
           UpperCamelCase__							:       Tuple      =   model(**__magic_name__							)

       # verify the logits
       UpperCamelCase__							:       Tuple      =   torch.Size((1, 1000)							)
       self.assertEqual(outputs.logits.shape,	__magic_name__							)

       UpperCamelCase__							:       List[Any]      =   torch.tensor([0.9285, 0.9015, -0.3150]							).to(__magic_name__							)

       self.assertTrue(torch.allclose(outputs.logits[0, :3],	__magic_name__,	atol=1E-4							)							)

