





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






							"""simple docstring"""

							snake_case_							 =						ShapEPipeline
							snake_case_							 =						["prompt"]
							snake_case_							 =						["prompt"]
							snake_case_							 =						[
							    "num_images_per_prompt",
							    "num_inference_steps",
							    "generator",
							    "latents",
							    "guidance_scale",
							    "frame_size",
							    "output_type",
							    "return_dict",
							]
							snake_case_							 =						False

							@property
							def      A_  (      self				:     Dict    )	->List[Any]:
													return 32

							@property
							def      A_  (      self				:     str    )	->Optional[int]:
													return 32

							@property
							def      A_  (      self				:     Tuple    )	->List[str]:
													return self.time_input_dim * 4

							@property
							def      A_  (      self				:     Any    )	->List[Any]:
													return 8

							@property
							def      A_  (      self				:     List[str]    )	->Tuple:
													SCREAMING_SNAKE_CASE__     :				List[Any]   =					CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"    )
													return tokenizer

							@property
							def      A_  (      self				:     Dict    )	->Any:
													torch.manual_seed(0    )
													SCREAMING_SNAKE_CASE__     :				str   =					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=10_00							,	)
													return CLIPTextModelWithProjection(a    )

							@property
							def      A_  (      self				:     Optional[int]    )	->Tuple:
													torch.manual_seed(0    )

													SCREAMING_SNAKE_CASE__     :				Union[str, 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,
													}

													SCREAMING_SNAKE_CASE__     :				Any   =					PriorTransformer(**a    )
													return model

							@property
							def      A_  (      self				:     Dict    )	->List[str]:
													torch.manual_seed(0    )

													SCREAMING_SNAKE_CASE__     :				int   =					{
													    "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__     :				Optional[int]   =					ShapERenderer(**a    )
													return model

							def      A_  (      self				:     List[str]    )	->Any:
													SCREAMING_SNAKE_CASE__     :				List[str]   =					self.dummy_prior
													SCREAMING_SNAKE_CASE__     :				Tuple   =					self.dummy_text_encoder
													SCREAMING_SNAKE_CASE__     :				Optional[Any]   =					self.dummy_tokenizer
													SCREAMING_SNAKE_CASE__     :				Optional[Any]   =					self.dummy_renderer

													SCREAMING_SNAKE_CASE__     :				Tuple   =					HeunDiscreteScheduler(
													    beta_schedule="exp"							,	num_train_timesteps=10_24							,	prediction_type="sample"							,	use_karras_sigmas=a							,	clip_sample=a							,	clip_sample_range=1.0							,	)
													SCREAMING_SNAKE_CASE__     :				Optional[Any]   =					{
													    "prior": prior,
													    "text_encoder": text_encoder,
													    "tokenizer": tokenizer,
													    "renderer": renderer,
													    "scheduler": scheduler,
													}

													return components

							def      A_  (      self				:     Tuple							,	a				:     str							,	a				:     str=0    )	->Optional[Any]:
													if str(a    ).startswith("mps"    ):
																			SCREAMING_SNAKE_CASE__     :				Tuple   =					torch.manual_seed(a    )
													else:
																			SCREAMING_SNAKE_CASE__     :				Optional[int]   =					torch.Generator(device=a    ).manual_seed(a    )
													SCREAMING_SNAKE_CASE__     :				List[Any]   =					{
													    "prompt": "horse",
													    "generator": generator,
													    "num_inference_steps": 1,
													    "frame_size": 32,
													    "output_type": "np",
													}
													return inputs

							def      A_  (      self				:     str    )	->Any:
													SCREAMING_SNAKE_CASE__     :				Optional[int]   =					"cpu"

													SCREAMING_SNAKE_CASE__     :				str   =					self.get_dummy_components()

													SCREAMING_SNAKE_CASE__     :				Optional[Any]   =					self.pipeline_class(**a    )
													SCREAMING_SNAKE_CASE__     :				str   =					pipe.to(a    )

													pipe.set_progress_bar_config(disable=a    )

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

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

													SCREAMING_SNAKE_CASE__     :				Optional[Any]   =					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      A_  (      self				:     List[str]    )	->List[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				:     List[str]    )	->List[str]:
													SCREAMING_SNAKE_CASE__     :				Union[str, Any]   =					torch_device == "cpu"
													SCREAMING_SNAKE_CASE__     :				List[str]   =					True

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






							def      A_  (      self				:     Dict    )	->List[str]:
													SCREAMING_SNAKE_CASE__     :				Tuple   =					self.get_dummy_components()
													SCREAMING_SNAKE_CASE__     :				List[str]   =					self.pipeline_class(**a    )
													SCREAMING_SNAKE_CASE__     :				Optional[Any]   =					pipe.to(a    )
													pipe.set_progress_bar_config(disable=a    )

													SCREAMING_SNAKE_CASE__     :				int   =					1
													SCREAMING_SNAKE_CASE__     :				Dict   =					2

													SCREAMING_SNAKE_CASE__     :				int   =					self.get_dummy_inputs(a    )

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

													SCREAMING_SNAKE_CASE__     :				Union[str, Any]   =					pipe(**a							,	num_images_per_prompt=a    )[0]

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







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






							"""simple docstring"""

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






							def      A_  (      self				:     Tuple    )	->Optional[Any]:
													SCREAMING_SNAKE_CASE__     :				Optional[Any]   =					load_numpy(
													    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
													    "/shap_e/test_shap_e_np_out.npy"    )
													SCREAMING_SNAKE_CASE__     :				Tuple   =					ShapEPipeline.from_pretrained("openai/shap-e"    )
													SCREAMING_SNAKE_CASE__     :				Union[str, Any]   =					pipe.to(a    )
													pipe.set_progress_bar_config(disable=a    )

													SCREAMING_SNAKE_CASE__     :				Tuple   =					torch.Generator(device=a    ).manual_seed(0    )

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






from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


__lowercase       :str       =  {
    "configuration_upernet": ["UperNetConfig"],
}

try:
				if not is_torch_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				__lowercase       :Union[str, Any]       =  [
				    "UperNetForSemanticSegmentation",
				    "UperNetPreTrainedModel",
				]


if TYPE_CHECKING:
				from .configuration_upernet import UperNetConfig

				try:
								if not is_torch_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_upernet import UperNetForSemanticSegmentation, UperNetPreTrainedModel


else:
				import sys

				__lowercase       :str       =  _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)