






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

						"""simple docstring"""



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



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




											'''simple docstring'''



											return 32



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




											'''simple docstring'''



											return 32



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




											'''simple docstring'''



											return self.time_input_dim * 4



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




											'''simple docstring'''



											return 8



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




											'''simple docstring'''



											torch.manual_seed(0   )
											__a					:						Tuple      =					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 ,					)

											__a					:						str      =					CLIPVisionModel(__UpperCAmelCase   )
											return model



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




											'''simple docstring'''



											__a					:						Dict      =					CLIPImageProcessor(
											    crop_size=224 ,					do_center_crop=__UpperCAmelCase ,					do_normalize=__UpperCAmelCase ,					do_resize=__UpperCAmelCase ,					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:					Union[str, Any]   )    ->     Tuple:




											'''simple docstring'''



											torch.manual_seed(0   )

											__a					:						str      =					{
											    "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,
											}

											__a					:						List[Any]      =					PriorTransformer(**__UpperCAmelCase   )
											return model



						@property
						def        UpperCAmelCase__					(self:					Dict   )    ->     int:




											'''simple docstring'''



											torch.manual_seed(0   )

											__a					:						Any      =					{
											    "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,
											    ),
											}
											__a					:						Union[str, Any]      =					ShapERenderer(**__UpperCAmelCase   )
											return model



						def        UpperCAmelCase__					(self:					str   )    ->     Tuple:




											'''simple docstring'''



											__a					:						List[str]      =					self.dummy_prior
											__a					:						Tuple      =					self.dummy_image_encoder
											__a					:						Union[str, Any]      =					self.dummy_image_processor
											__a					:						Optional[Any]      =					self.dummy_renderer

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

											return components



						def        UpperCAmelCase__					(self:					Tuple ,					__UpperCAmelCase:					Union[str, Any] ,					__UpperCAmelCase:					Any=0   )    ->     str:




											'''simple docstring'''



											__a					:						int      =					floats_tensor((1, 3, 64, 64) ,					rng=random.Random(__UpperCAmelCase   )   ).to(__UpperCAmelCase   )

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



						def        UpperCAmelCase__					(self:					Optional[int]   )    ->     List[Any]:




											'''simple docstring'''



											__a					:						List[str]      =					"cpu"

											__a					:						Optional[int]      =					self.get_dummy_components()

											__a					:						Dict      =					self.pipeline_class(**__UpperCAmelCase   )
											__a					:						Union[str, Any]      =					pipe.to(__UpperCAmelCase   )

											pipe.set_progress_bar_config(disable=__UpperCAmelCase   )

											__a					:						List[Any]      =					pipe(**self.get_dummy_inputs(__UpperCAmelCase   )   )
											__a					:						int      =					output.images[0]
											__a					:						Union[str, Any]      =					image[0, -3:, -3:, -1]

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

											__a					:						List[str]      =					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:					Optional[int]   )    ->     int:




											'''simple docstring'''



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



						def        UpperCAmelCase__					(self:					Any   )    ->     Optional[int]:




											'''simple docstring'''



											__a					:						Union[str, Any]      =					torch_device == "cpu"
											__a					:						Optional[Any]      =					True
											self._test_inference_batch_single_identical(
											    batch_size=2 ,					test_max_difference=__UpperCAmelCase ,					relax_max_difference=__UpperCAmelCase ,					)



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




											'''simple docstring'''



											__a					:						Optional[int]      =					self.get_dummy_components()
											__a					:						Dict      =					self.pipeline_class(**__UpperCAmelCase   )
											__a					:						List[str]      =					pipe.to(__UpperCAmelCase   )
											pipe.set_progress_bar_config(disable=__UpperCAmelCase   )

											__a					:						str      =					1
											__a					:						Dict      =					2

											__a					:						Union[str, Any]      =					self.get_dummy_inputs(__UpperCAmelCase   )

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

											__a					:						Dict      =					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        UpperCAmelCase__					(self:					List[Any]   )    ->     str:




											'''simple docstring'''



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



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




											'''simple docstring'''



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

											__a					:						int      =					torch.Generator(device=__UpperCAmelCase   ).manual_seed(0   )

											__a					:						Tuple      =					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   )













UpperCAmelCase__      			=						'''Input must be a string of 8 numbers plus letter'''
UpperCAmelCase__      			=						'''TRWAGMYFPDXBNJZSQVHLCKE'''







def     a_   (__A      )				->						bool:



					"""simple docstring"""

					if not isinstance(__A				,       __A      ):
										__a					:						Any      =					f'Expected string as input, found {type(__A      ).__name__}'
										raise TypeError(__A      )

					__a					:						int      =					spanish_id.replace("-"				,       ""      ).upper()
					if len(__A      ) != 9:
										raise ValueError(__A      )

					try:
										__a					:						Tuple      =					int(spanish_id_clean[0:8]      )
										__a					:						Optional[int]      =					spanish_id_clean[8]
					except ValueError as ex:
										raise ValueError(__A      ) from ex

					if letter.isdigit():
										raise ValueError(__A      )

					return letter == LOOKUP_LETTERS[number % 23]


if __name__ == "__main__":
			import doctest

			doctest.testmod()





