



"""simple docstring"""


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 (					lowerCAmelCase			,							unittest.TestCase):
			"""simple docstring"""
			UpperCamelCase__			      =	ShapEImgaImgPipeline
			UpperCamelCase__			      =	["""image"""]
			UpperCamelCase__			      =	["""image"""]
			UpperCamelCase__			      =	[
			    """num_images_per_prompt""",
			    """num_inference_steps""",
			    """generator""",
			    """latents""",
			    """guidance_scale""",
			    """frame_size""",
			    """output_type""",
			    """return_dict""",
			]
			UpperCamelCase__			      =	False



			@property
			def  lowercase__						(		self     :    str   )->List[str]:
							return 3_2



			@property
			def  lowercase__						(		self     :    int   )->List[Any]:
							return 3_2



			@property
			def  lowercase__						(		self     :    Tuple   )->Optional[Any]:
							return self.time_input_dim * 4



			@property
			def  lowercase__						(		self     :    Union[str, Any]   )->Union[str, Any]:
							return 8



			@property
			def  lowercase__						(		self     :    Tuple   )->str:
							torch.manual_seed(0   )
							_UpperCAmelCase					=    CLIPVisionConfig(
							    hidden_size=self.text_embedder_hidden_size				,   image_size=6_4				,   projection_dim=self.text_embedder_hidden_size				,   intermediate_size=3_7				,   num_attention_heads=4				,   num_channels=3				,   num_hidden_layers=5				,   patch_size=1				,   )

							_UpperCAmelCase					=    CLIPVisionModel(__UpperCamelCase   )
							return model



			@property
			def  lowercase__						(		self     :    str   )->Union[str, Any]:
							_UpperCAmelCase					=    CLIPImageProcessor(
							    crop_size=2_2_4				,   do_center_crop=__UpperCamelCase				,   do_normalize=__UpperCamelCase				,   do_resize=__UpperCamelCase				,   image_mean=[0.4_8_1_4_5_4_6_6, 0.4_5_7_8_2_7_5, 0.4_0_8_2_1_0_7_3]				,   image_std=[0.2_6_8_6_2_9_5_4, 0.2_6_1_3_0_2_5_8, 0.2_7_5_7_7_7_1_1]				,   resample=3				,   size=2_2_4				,   )

							return image_processor



			@property
			def  lowercase__						(		self     :    List[str]   )->Optional[Any]:
							torch.manual_seed(0   )

							_UpperCAmelCase					=    {
							    '''num_attention_heads''': 2,
							    '''attention_head_dim''': 1_6,
							    '''embedding_dim''': self.time_input_dim,
							    '''num_embeddings''': 3_2,
							    '''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					=    PriorTransformer(**__UpperCamelCase   )
							return model



			@property
			def  lowercase__						(		self     :    List[Any]   )->Tuple:
							torch.manual_seed(0   )

							_UpperCAmelCase					=    {
							    '''param_shapes''': (
							        (self.renderer_dim, 9_3),
							        (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''': 1_2,
							    '''background''': (
							        0.1,
							        0.1,
							        0.1,
							    ),
							}
							_UpperCAmelCase					=    ShapERenderer(**__UpperCamelCase   )
							return model



			def  lowercase__						(		self     :    int   )->List[Any]:
							_UpperCAmelCase					=    self.dummy_prior
							_UpperCAmelCase					=    self.dummy_image_encoder
							_UpperCAmelCase					=    self.dummy_image_processor
							_UpperCAmelCase					=    self.dummy_renderer

							_UpperCAmelCase					=    HeunDiscreteScheduler(
							    beta_schedule='''exp'''				,   num_train_timesteps=1_0_2_4				,   prediction_type='''sample'''				,   use_karras_sigmas=__UpperCamelCase				,   clip_sample=__UpperCamelCase				,   clip_sample_range=1.0				,   )
							_UpperCAmelCase					=    {
							    '''prior''': prior,
							    '''image_encoder''': image_encoder,
							    '''image_processor''': image_processor,
							    '''renderer''': renderer,
							    '''scheduler''': scheduler,
							}

							return components



			def  lowercase__						(		self     :    Union[str, Any]				,   __UpperCamelCase     :    Union[str, Any]				,   __UpperCamelCase     :    Tuple=0   )->str:
							_UpperCAmelCase					=    floats_tensor((1, 3, 6_4, 6_4)				,   rng=random.Random(__UpperCamelCase   )   ).to(__UpperCamelCase   )

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



			def  lowercase__						(		self     :    List[Any]   )->int:
							_UpperCAmelCase					=    '''cpu'''

							_UpperCAmelCase					=    self.get_dummy_components()

							_UpperCAmelCase					=    self.pipeline_class(**__UpperCamelCase   )
							_UpperCAmelCase					=    pipe.to(__UpperCamelCase   )

							pipe.set_progress_bar_config(disable=__UpperCamelCase   )

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

							assert image.shape == (2_0, 3_2, 3_2, 3)

							_UpperCAmelCase					=    np.array(
							    [
							        0.0_0_0_3_9_2_1_6,
							        0.0_0_0_3_9_2_1_6,
							        0.0_0_0_3_9_2_1_6,
							        0.0_0_0_3_9_2_1_6,
							        0.0_0_0_3_9_2_1_6,
							        0.0_0_0_3_9_2_1_6,
							        0.0_0_0_3_9_2_1_6,
							        0.0_0_0_3_9_2_1_6,
							        0.0_0_0_3_9_2_1_6,
							    ]   )

							assert np.abs(image_slice.flatten() - expected_slice   ).max() < 1e-2



			def  lowercase__						(		self     :    str   )->List[Any]:
							# NOTE: Larger batch sizes cause this test to timeout, only test on smaller batches
							self._test_inference_batch_consistent(batch_sizes=[1, 2]   )



			def  lowercase__						(		self     :    int   )->Optional[int]:
							_UpperCAmelCase					=    torch_device == '''cpu'''
							_UpperCAmelCase					=    True
							self._test_inference_batch_single_identical(
							    batch_size=2				,   test_max_difference=__UpperCamelCase				,   relax_max_difference=__UpperCamelCase				,   )



			def  lowercase__						(		self     :    List[str]   )->Optional[Any]:
							_UpperCAmelCase					=    self.get_dummy_components()
							_UpperCAmelCase					=    self.pipeline_class(**__UpperCamelCase   )
							_UpperCAmelCase					=    pipe.to(__UpperCamelCase   )
							pipe.set_progress_bar_config(disable=__UpperCamelCase   )

							_UpperCAmelCase					=    1
							_UpperCAmelCase					=    2

							_UpperCAmelCase					=    self.get_dummy_inputs(__UpperCamelCase   )

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

							_UpperCAmelCase					=    pipe(**__UpperCamelCase				,   num_images_per_prompt=__UpperCamelCase   )[0]

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



@slow
@require_torch_gpu
class 			_a (					unittest.TestCase):
			"""simple docstring"""



			def  lowercase__						(		self     :    int   )->Union[str, Any]:
							# clean up the VRAM after each test
							super().tearDown()
							gc.collect()
							torch.cuda.empty_cache()



			def  lowercase__						(		self     :    str   )->int:
							_UpperCAmelCase					=    load_image(
							    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main''' '''/shap_e/corgi.png'''   )
							_UpperCAmelCase					=    load_numpy(
							    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
							    '''/shap_e/test_shap_e_img2img_out.npy'''   )
							_UpperCAmelCase					=    ShapEImgaImgPipeline.from_pretrained('''openai/shap-e-img2img'''   )
							_UpperCAmelCase					=    pipe.to(__UpperCamelCase   )
							pipe.set_progress_bar_config(disable=__UpperCamelCase   )

							_UpperCAmelCase					=    torch.Generator(device=__UpperCamelCase   ).manual_seed(0   )

							_UpperCAmelCase					=    pipe(
							    __UpperCamelCase				,   generator=__UpperCamelCase				,   guidance_scale=3.0				,   num_inference_steps=6_4				,   frame_size=6_4				,   output_type='''np'''				,   ).images[0]

							assert images.shape == (2_0, 6_4, 6_4, 3)

							assert_mean_pixel_difference(__UpperCamelCase				,   __UpperCamelCase   )








"""simple docstring"""


from typing import Optional

from .. import Features, NamedSplit
from ..packaged_modules.text.text import Text
from ..utils.typing import NestedDataStructureLike, PathLike
from .abc import AbstractDatasetReader
class 			_a (					lowerCAmelCase):
			"""simple docstring"""



			def __init__(		self     :    List[str]				,   __UpperCamelCase     :    NestedDataStructureLike[PathLike]				,   __UpperCamelCase     :    Optional[NamedSplit] = None				,   __UpperCamelCase     :    Optional[Features] = None				,   __UpperCamelCase     :    str = None				,   __UpperCamelCase     :    bool = False				,   __UpperCamelCase     :    bool = False				,   __UpperCamelCase     :    Optional[int] = None				,   **__UpperCamelCase     :    Optional[Any]				,   )->Any:
							super().__init__(
							    __UpperCamelCase				,   split=__UpperCamelCase				,   features=__UpperCamelCase				,   cache_dir=__UpperCamelCase				,   keep_in_memory=__UpperCamelCase				,   streaming=__UpperCamelCase				,   num_proc=__UpperCamelCase				,   **__UpperCamelCase				,   )
							_UpperCAmelCase					=    path_or_paths if isinstance(__UpperCamelCase				,   __UpperCamelCase   ) else {self.split: path_or_paths}
							_UpperCAmelCase					=    Text(
							    cache_dir=__UpperCamelCase				,   data_files=__UpperCamelCase				,   features=__UpperCamelCase				,   **__UpperCamelCase				,   )



			def  lowercase__						(		self     :    Optional[Any]   )->str:
							# Build iterable dataset
							if self.streaming:
											_UpperCAmelCase					=    self.builder.as_streaming_dataset(split=self.split   )
							# Build regular (map-style) dataset
							else:
											_UpperCAmelCase					=    None
											_UpperCAmelCase					=    None
											_UpperCAmelCase					=    None
											_UpperCAmelCase					=    None

											self.builder.download_and_prepare(
											    download_config=__UpperCamelCase				,   download_mode=__UpperCamelCase				,   verification_mode=__UpperCamelCase				,   base_path=__UpperCamelCase				,   num_proc=self.num_proc				,   )
											_UpperCAmelCase					=    self.builder.as_dataset(
											    split=self.split				,   verification_mode=__UpperCamelCase				,   in_memory=self.keep_in_memory   )
							return dataset



