




import os
from pathlib import Path

def 			a   ():
							from torch.utils.cpp_extension import load

							SCREAMING_SNAKE_CASE_   	=    Path(snake_case_     ).resolve().parent.parent.parent / '''kernels''' / '''deformable_detr'''
							SCREAMING_SNAKE_CASE_   	=    [
							    root / filename
							    for filename in [
							        '''vision.cpp''',
							        os.path.join('''cpu'''  ,    '''ms_deform_attn_cpu.cpp'''     ),
							        os.path.join('''cuda'''  ,    '''ms_deform_attn_cuda.cu'''     ),
							    ]
							]

							load(
							    '''MultiScaleDeformableAttention'''  ,    snake_case_  ,    with_cuda=snake_case_  ,    extra_include_paths=[str(snake_case_     )]  ,    extra_cflags=['''-DWITH_CUDA=1''']  ,    extra_cuda_cflags=[
							        '''-DCUDA_HAS_FP16=1''',
							        '''-D__CUDA_NO_HALF_OPERATORS__''',
							        '''-D__CUDA_NO_HALF_CONVERSIONS__''',
							        '''-D__CUDA_NO_HALF2_OPERATORS__''',
							    ]  ,    )

							import MultiScaleDeformableAttention as MSDA

							return MSDA








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  __magic_name__						(  __UpperCAmelCase    ,  unittest.TestCase):
				'''simple docstring'''







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


				@property
				def     _A							(							self:   Optional[Any]		):
											return 32


				@property
				def     _A							(							self:   Optional[int]		):
											return 32


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


				@property
				def     _A							(							self:   Any		):
											return 8


				@property
				def     _A							(							self:   int		):
											torch.manual_seed(0		)
											SCREAMING_SNAKE_CASE_   	=    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		,					)

											SCREAMING_SNAKE_CASE_   	=    CLIPVisionModel(_lowerCamelCase		)
											return model


				@property
				def     _A							(							self:   List[Any]		):
											SCREAMING_SNAKE_CASE_   	=    CLIPImageProcessor(
											    crop_size=2_24		,					do_center_crop=_lowerCamelCase		,					do_normalize=_lowerCamelCase		,					do_resize=_lowerCamelCase		,					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=2_24		,					)

											return image_processor


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

											SCREAMING_SNAKE_CASE_   	=    {
											    '''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,
											}

											SCREAMING_SNAKE_CASE_   	=    PriorTransformer(**_lowerCamelCase		)
											return model


				@property
				def     _A							(							self:   List[Any]		):
											torch.manual_seed(0		)

											SCREAMING_SNAKE_CASE_   	=    {
											    '''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,
											    ),
											}
											SCREAMING_SNAKE_CASE_   	=    ShapERenderer(**_lowerCamelCase		)
											return model


				def     _A							(							self:   Optional[int]		):
											SCREAMING_SNAKE_CASE_   	=    self.dummy_prior
											SCREAMING_SNAKE_CASE_   	=    self.dummy_image_encoder
											SCREAMING_SNAKE_CASE_   	=    self.dummy_image_processor
											SCREAMING_SNAKE_CASE_   	=    self.dummy_renderer

											SCREAMING_SNAKE_CASE_   	=    HeunDiscreteScheduler(
											    beta_schedule='''exp'''		,					num_train_timesteps=10_24		,					prediction_type='''sample'''		,					use_karras_sigmas=_lowerCamelCase		,					clip_sample=_lowerCamelCase		,					clip_sample_range=1.0		,					)
											SCREAMING_SNAKE_CASE_   	=    {
											    '''prior''': prior,
											    '''image_encoder''': image_encoder,
											    '''image_processor''': image_processor,
											    '''renderer''': renderer,
											    '''scheduler''': scheduler,
											}

											return components


				def     _A							(							self:   Optional[Any]		,					_lowerCamelCase:   List[Any]		,					_lowerCamelCase:   Optional[Any]=0		):
											SCREAMING_SNAKE_CASE_   	=    floats_tensor((1, 3, 64, 64)		,					rng=random.Random(_lowerCamelCase		)		).to(_lowerCamelCase		)

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


				def     _A							(							self:   Any		):
											SCREAMING_SNAKE_CASE_   	=    '''cpu'''

											SCREAMING_SNAKE_CASE_   	=    self.get_dummy_components()

											SCREAMING_SNAKE_CASE_   	=    self.pipeline_class(**_lowerCamelCase		)
											SCREAMING_SNAKE_CASE_   	=    pipe.to(_lowerCamelCase		)

											pipe.set_progress_bar_config(disable=_lowerCamelCase		)

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

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

											SCREAMING_SNAKE_CASE_   	=    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     _A							(							self:   str		):
											# NOTE: Larger batch sizes cause this test to timeout, only test on smaller batches
											self._test_inference_batch_consistent(batch_sizes=[1, 2]		)


				def     _A							(							self:   Tuple		):
											SCREAMING_SNAKE_CASE_   	=    torch_device == '''cpu'''
											SCREAMING_SNAKE_CASE_   	=    True
											self._test_inference_batch_single_identical(
											    batch_size=2		,					test_max_difference=_lowerCamelCase		,					relax_max_difference=_lowerCamelCase		,					)





				def     _A							(							self:   Tuple		):
											SCREAMING_SNAKE_CASE_   	=    self.get_dummy_components()
											SCREAMING_SNAKE_CASE_   	=    self.pipeline_class(**_lowerCamelCase		)
											SCREAMING_SNAKE_CASE_   	=    pipe.to(_lowerCamelCase		)
											pipe.set_progress_bar_config(disable=_lowerCamelCase		)

											SCREAMING_SNAKE_CASE_   	=    1
											SCREAMING_SNAKE_CASE_   	=    2

											SCREAMING_SNAKE_CASE_   	=    self.get_dummy_inputs(_lowerCamelCase		)

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

											SCREAMING_SNAKE_CASE_   	=    pipe(**_lowerCamelCase		,					num_images_per_prompt=_lowerCamelCase		)[0]

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






@slow
@require_torch_gpu
class  __magic_name__						(  unittest.TestCase):
				'''simple docstring'''







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





				def     _A							(							self:   Optional[int]		):
											SCREAMING_SNAKE_CASE_   	=    load_image(
											    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main''' '''/shap_e/corgi.png'''		)
											SCREAMING_SNAKE_CASE_   	=    load_numpy(
											    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
											    '''/shap_e/test_shap_e_img2img_out.npy'''		)
											SCREAMING_SNAKE_CASE_   	=    ShapEImgaImgPipeline.from_pretrained('''openai/shap-e-img2img'''		)
											SCREAMING_SNAKE_CASE_   	=    pipe.to(_lowerCamelCase		)
											pipe.set_progress_bar_config(disable=_lowerCamelCase		)

											SCREAMING_SNAKE_CASE_   	=    torch.Generator(device=_lowerCamelCase		).manual_seed(0		)

											SCREAMING_SNAKE_CASE_   	=    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		)


