




'''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 		SCREAMING_SNAKE_CASE__  (			_UpperCamelCase				,     unittest.TestCase	):
			__SCREAMING_SNAKE_CASE    =			ShapEImgaImgPipeline
			__SCREAMING_SNAKE_CASE    =			["""image"""]
			__SCREAMING_SNAKE_CASE    =			["""image"""]
			__SCREAMING_SNAKE_CASE    =			[
			    """num_images_per_prompt""",
			    """num_inference_steps""",
			    """generator""",
			    """latents""",
			    """guidance_scale""",
			    """frame_size""",
			    """output_type""",
			    """return_dict""",
			]
			__SCREAMING_SNAKE_CASE    =			False





			@property
			def 							A (      self						:    int							):



						"""simple docstring"""




						return 32





			@property
			def 							A (      self						:    Optional[Any]							):



						"""simple docstring"""




						return 32





			@property
			def 							A (      self						:    str							):



						"""simple docstring"""




						return self.time_input_dim * 4





			@property
			def 							A (      self						:    Dict							):



						"""simple docstring"""




						return 8





			@property
			def 							A (      self						:    Optional[int]							):



						"""simple docstring"""




						torch.manual_seed(0							)
						__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      ,		)

						__snake_case			=		CLIPVisionModel(a_							)
						return model





			@property
			def 							A (      self						:    str							):



						"""simple docstring"""




						__snake_case			=		CLIPImageProcessor(
						    crop_size=224      ,		do_center_crop=a_      ,		do_normalize=a_      ,		do_resize=a_      ,		image_mean=[0.48145466, 0.4578275, 0.40821073]      ,		image_std=[0.26862954, 0.26130258, 0.27577711]      ,		resample=3      ,		size=224      ,		)

						return image_processor





			@property
			def 							A (      self						:    Union[str, Any]							):



						"""simple docstring"""




						torch.manual_seed(0							)

						__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,
						}

						__snake_case			=		PriorTransformer(**a_							)
						return model





			@property
			def 							A (      self						:    List[str]							):



						"""simple docstring"""




						torch.manual_seed(0							)

						__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,
						    ),
						}
						__snake_case			=		ShapERenderer(**a_							)
						return model





			def 							A (      self						:    Optional[Any]							):



						"""simple docstring"""




						__snake_case			=		self.dummy_prior
						__snake_case			=		self.dummy_image_encoder
						__snake_case			=		self.dummy_image_processor
						__snake_case			=		self.dummy_renderer

						__snake_case			=		HeunDiscreteScheduler(
						    beta_schedule="exp"      ,		num_train_timesteps=1_024      ,		prediction_type="sample"      ,		use_karras_sigmas=a_      ,		clip_sample=a_      ,		clip_sample_range=1.0      ,		)
						__snake_case			=		{
						    "prior": prior,
						    "image_encoder": image_encoder,
						    "image_processor": image_processor,
						    "renderer": renderer,
						    "scheduler": scheduler,
						}

						return components





			def 							A (      self						:    Optional[int]      ,		a_						:    Union[str, Any]      ,		a_						:    int=0							):



						"""simple docstring"""




						__snake_case			=		floats_tensor((1, 3, 64, 64)      ,		rng=random.Random(a_							)							).to(a_							)

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





			def 							A (      self						:    List[str]							):



						"""simple docstring"""




						__snake_case			=		"cpu"

						__snake_case			=		self.get_dummy_components()

						__snake_case			=		self.pipeline_class(**a_							)
						__snake_case			=		pipe.to(a_							)

						pipe.set_progress_bar_config(disable=a_							)

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

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

						__snake_case			=		np.array(
						    [
						        0.00039216,
						        0.00039216,
						        0.00039216,
						        0.00039216,
						        0.00039216,
						        0.00039216,
						        0.00039216,
						        0.00039216,
						        0.00039216,
						    ]							)

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





			def 							A (      self						:    List[Any]							):



						"""simple docstring"""




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





			def 							A (      self						:    Union[str, Any]							):



						"""simple docstring"""




						__snake_case			=		torch_device == "cpu"
						__snake_case			=		True
						self._test_inference_batch_single_identical(
						    batch_size=2      ,		test_max_difference=a_      ,		relax_max_difference=a_      ,		)






			def 							A (      self						:    Any							):



						"""simple docstring"""




						__snake_case			=		self.get_dummy_components()
						__snake_case			=		self.pipeline_class(**a_							)
						__snake_case			=		pipe.to(a_							)
						pipe.set_progress_bar_config(disable=a_							)

						__snake_case			=		1
						__snake_case			=		2

						__snake_case			=		self.get_dummy_inputs(a_							)

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

						__snake_case			=		pipe(**a_      ,		num_images_per_prompt=a_							)[0]

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







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





			def 							A (      self						:    List[str]							):



						"""simple docstring"""




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






			def 							A (      self						:    str							):



						"""simple docstring"""




						__snake_case			=		load_image(
						    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main" "/shap_e/corgi.png"							)
						__snake_case			=		load_numpy(
						    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
						    "/shap_e/test_shap_e_img2img_out.npy"							)
						__snake_case			=		ShapEImgaImgPipeline.from_pretrained("openai/shap-e-img2img"							)
						__snake_case			=		pipe.to(a_							)
						pipe.set_progress_bar_config(disable=a_							)

						__snake_case			=		torch.Generator(device=a_							).manual_seed(0							)

						__snake_case			=		pipe(
						    a_      ,		generator=a_      ,		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(a_      ,		a_							)











from __future__ import annotations

import inspect
import unittest

import numpy as np

from transformers import ResNetConfig
from transformers.testing_utils import require_tf, require_vision, slow
from transformers.utils import cached_property, is_tf_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
						import tensorflow as tf

						from transformers import TFResNetForImageClassification, TFResNetModel
						from transformers.models.resnet.modeling_tf_resnet import TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
						from PIL import Image

						from transformers import AutoImageProcessor



class    lowercase_		:



						def __init__(			self	:   Optional[Any]					,							snake_case__	:   List[Any]					,							snake_case__	:   Tuple=3					,							snake_case__	:   Union[str, Any]=32					,							snake_case__	:   Union[str, Any]=3					,							snake_case__	:   str=10					,							snake_case__	:   List[Any]=[10, 20, 30, 40]					,							snake_case__	:   Optional[Any]=[1, 1, 2, 1]					,							snake_case__	:   str=True					,							snake_case__	:   str=True					,							snake_case__	:   List[str]="relu"					,							snake_case__	:   Tuple=3					,							snake_case__	:   str=None					,							):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							parent
								SCREAMING_SNAKE_CASE_					      =							batch_size
								SCREAMING_SNAKE_CASE_					      =							image_size
								SCREAMING_SNAKE_CASE_					      =							num_channels
								SCREAMING_SNAKE_CASE_					      =							embeddings_size
								SCREAMING_SNAKE_CASE_					      =							hidden_sizes
								SCREAMING_SNAKE_CASE_					      =							depths
								SCREAMING_SNAKE_CASE_					      =							is_training
								SCREAMING_SNAKE_CASE_					      =							use_labels
								SCREAMING_SNAKE_CASE_					      =							hidden_act
								SCREAMING_SNAKE_CASE_					      =							num_labels
								SCREAMING_SNAKE_CASE_					      =							scope
								SCREAMING_SNAKE_CASE_					      =							len(snake_case__  )



						def 	__a					(			self	:   Any  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]  )

								SCREAMING_SNAKE_CASE_					      =							None
								if self.use_labels:
										SCREAMING_SNAKE_CASE_					      =							ids_tensor([self.batch_size]					,							self.num_labels  )

								SCREAMING_SNAKE_CASE_					      =							self.get_config()

								return config, pixel_values, labels



						def 	__a					(			self	:   int  ):

								"""simple docstring"""

								return ResNetConfig(
								    num_channels=self.num_channels					,							embeddings_size=self.embeddings_size					,							hidden_sizes=self.hidden_sizes					,							depths=self.depths					,							hidden_act=self.hidden_act					,							num_labels=self.num_labels					,							image_size=self.image_size					,							)



						def 	__a					(			self	:   str					,							snake_case__	:   str					,							snake_case__	:   Tuple					,							snake_case__	:   Optional[Any]  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							TFResNetModel(config=snake_case__  )
								SCREAMING_SNAKE_CASE_					      =							model(snake_case__  )
								# expected last hidden states: B, C, H // 32, W // 32
								self.parent.assertEqual(
								    result.last_hidden_state.shape					,							(self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32)					,							)



						def 	__a					(			self	:   int					,							snake_case__	:   Optional[Any]					,							snake_case__	:   int					,							snake_case__	:   Any  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							self.num_labels
								SCREAMING_SNAKE_CASE_					      =							TFResNetForImageClassification(snake_case__  )
								SCREAMING_SNAKE_CASE_					      =							model(snake_case__					,							labels=snake_case__  )
								self.parent.assertEqual(result.logits.shape					,							(self.batch_size, self.num_labels)  )






						def 	__a					(			self	:   Dict  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							self.prepare_config_and_inputs()
								SCREAMING_SNAKE_CASE_      ,				SCREAMING_SNAKE_CASE_      ,				SCREAMING_SNAKE_CASE_					      =							config_and_inputs
								SCREAMING_SNAKE_CASE_					      =							{'pixel_values': pixel_values}
								return config, inputs_dict



@require_tf
class    lowercase_		(SCREAMING_SNAKE_CASE__							,	SCREAMING_SNAKE_CASE__							,	unittest.TestCase ):
						lowerCAmelCase__			      =(TFResNetModel, TFResNetForImageClassification) if is_tf_available() else ()
						lowerCAmelCase__			      =(
						    {"feature-extraction": TFResNetModel, "image-classification": TFResNetForImageClassification}
						    if is_tf_available()
						    else {}
						)

						lowerCAmelCase__			      =False
						lowerCAmelCase__			      =False
						lowerCAmelCase__			      =False
						lowerCAmelCase__			      =False
						lowerCAmelCase__			      =False



						def 	__a					(			self	:   str  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							TFResNetModelTester(self  )
								SCREAMING_SNAKE_CASE_					      =							ConfigTester(self					,							config_class=snake_case__					,							has_text_modality=snake_case__  )



						def 	__a					(			self	:   Optional[Any]  ):

								"""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 	__a					(			self	:   List[Any]  ):

								"""simple docstring"""

								return



						@unittest.skip(reason='ResNet does not use inputs_embeds'  )
						def 	__a					(			self	:   Optional[Any]  ):

								"""simple docstring"""

								pass



						@unittest.skip(reason='ResNet does not support input and output embeddings'  )
						def 	__a					(			self	:   Tuple  ):

								"""simple docstring"""

								pass



						def 	__a					(			self	:   List[Any]  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_      ,				SCREAMING_SNAKE_CASE_					      =							self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
										SCREAMING_SNAKE_CASE_					      =							model_class(snake_case__  )
										SCREAMING_SNAKE_CASE_					      =							inspect.signature(model.call  )
										# signature.parameters is an OrderedDict => so arg_names order is deterministic
										SCREAMING_SNAKE_CASE_					      =							[*signature.parameters.keys()]

										SCREAMING_SNAKE_CASE_					      =							['pixel_values']
										self.assertListEqual(arg_names[:1]					,							snake_case__  )



						def 	__a					(			self	:   Union[str, Any]  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*snake_case__  )



						def 	__a					(			self	:   int  ):

								"""simple docstring"""

								def check_hidden_states_output(snake_case__	:   Optional[int]					,							snake_case__	:   int					,							snake_case__	:   Dict  ):
										SCREAMING_SNAKE_CASE_					      =							model_class(snake_case__  )
										SCREAMING_SNAKE_CASE_					      =							model(**self._prepare_for_class(snake_case__					,							snake_case__  )  )

										SCREAMING_SNAKE_CASE_					      =							outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

										SCREAMING_SNAKE_CASE_					      =							self.model_tester.num_stages
										self.assertEqual(len(snake_case__  )					,							expected_num_stages + 1  )

										# ResNet's feature maps are of shape (batch_size, num_channels, height, width)
										self.assertListEqual(
										    list(hidden_states[0].shape[-2:]  )					,							[self.model_tester.image_size // 4, self.model_tester.image_size // 4]					,							)

								SCREAMING_SNAKE_CASE_      ,				SCREAMING_SNAKE_CASE_					      =							self.model_tester.prepare_config_and_inputs_for_common()
								SCREAMING_SNAKE_CASE_					      =							['basic', 'bottleneck']
								for model_class in self.all_model_classes:
										for layer_type in layers_type:
												SCREAMING_SNAKE_CASE_					      =							layer_type
												SCREAMING_SNAKE_CASE_					      =							True
												check_hidden_states_output(snake_case__					,							snake_case__					,							snake_case__  )

												# check that output_hidden_states also work using config
												del inputs_dict["output_hidden_states"]
												SCREAMING_SNAKE_CASE_					      =							True

												check_hidden_states_output(snake_case__					,							snake_case__					,							snake_case__  )



						def 	__a					(			self	:   List[Any]  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_image_classification(*snake_case__  )






						@slow
						def 	__a					(			self	:   Tuple  ):

								"""simple docstring"""

								for model_name in TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
										SCREAMING_SNAKE_CASE_					      =							TFResNetModel.from_pretrained(snake_case__  )
										self.assertIsNotNone(snake_case__  )


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




@require_tf
@require_vision
class    lowercase_		(unittest.TestCase ):



						@cached_property
						def 	__a					(			self	:   List[Any]  ):

								"""simple docstring"""

								return (
								    AutoImageProcessor.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]  )
								    if is_vision_available()
								    else None
								)






						@slow
						def 	__a					(			self	:   Any  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							TFResNetForImageClassification.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]  )

								SCREAMING_SNAKE_CASE_					      =							self.default_image_processor
								SCREAMING_SNAKE_CASE_					      =							prepare_img()
								SCREAMING_SNAKE_CASE_					      =							image_processor(images=snake_case__					,							return_tensors='tf'  )

								# forward pass
								SCREAMING_SNAKE_CASE_					      =							model(**snake_case__  )

								# verify the logits
								SCREAMING_SNAKE_CASE_					      =							tf.TensorShape((1, 10_00)  )
								self.assertEqual(outputs.logits.shape					,							snake_case__  )

								SCREAMING_SNAKE_CASE_					      =							tf.constant([-11.10_69, -9.78_77, -8.37_77]  )

								self.assertTrue(np.allclose(outputs.logits[0, :3].numpy()					,							snake_case__					,							atol=1e-4  )  )