


'''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     __lowerCAmelCase		(lowercase_    ,	unittest.TestCase	):





      '''simple docstring'''






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



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

             '''simple docstring'''







             return 32



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

             '''simple docstring'''







             return 32



      @property
      def  UpperCamelCase__						(self       :       str					):

             '''simple docstring'''







             return self.time_input_dim * 4



      @property
      def  UpperCamelCase__						(self       :       Any					):

             '''simple docstring'''







             return 8



      @property
      def  UpperCamelCase__						(self       :       List[Any]					):

             '''simple docstring'''







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

             lowercase__      =					CLIPVisionModel(UpperCamelCase					)
             return model



      @property
      def  UpperCamelCase__						(self       :       str					):

             '''simple docstring'''







             lowercase__      =					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]					):

             '''simple docstring'''







             torch.manual_seed(0					)

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

             lowercase__      =					PriorTransformer(**UpperCamelCase					)
             return model



      @property
      def  UpperCamelCase__						(self       :       str					):

             '''simple docstring'''







             torch.manual_seed(0					)

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



      def  UpperCamelCase__						(self       :       Any					):

             '''simple docstring'''







             lowercase__      =					self.dummy_prior
             lowercase__      =					self.dummy_image_encoder
             lowercase__      =					self.dummy_image_processor
             lowercase__      =					self.dummy_renderer

             lowercase__      =					HeunDiscreteScheduler(
                 beta_schedule='''exp'''  ,		num_train_timesteps=1024  ,		prediction_type='''sample'''  ,		use_karras_sigmas=UpperCamelCase  ,		clip_sample=UpperCamelCase  ,		clip_sample_range=1.0  ,		)
             lowercase__      =					{
                 '''prior''': prior,
                 '''image_encoder''': image_encoder,
                 '''image_processor''': image_processor,
                 '''renderer''': renderer,
                 '''scheduler''': scheduler,
             }

             return components



      def  UpperCamelCase__						(self       :       Optional[int]  ,		UpperCamelCase       :       int  ,		UpperCamelCase       :       int=0					):

             '''simple docstring'''







             lowercase__      =					floats_tensor((1, 3, 64, 64)  ,		rng=random.Random(UpperCamelCase					)					).to(UpperCamelCase					)

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



      def  UpperCamelCase__						(self       :       List[str]					):

             '''simple docstring'''







             lowercase__      =					'''cpu'''

             lowercase__      =					self.get_dummy_components()

             lowercase__      =					self.pipeline_class(**UpperCamelCase					)
             lowercase__      =					pipe.to(UpperCamelCase					)

             pipe.set_progress_bar_config(disable=UpperCamelCase					)

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

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

             lowercase__      =					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       :       str					):

             '''simple docstring'''







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



      def  UpperCamelCase__						(self       :       List[Any]					):

             '''simple docstring'''







             lowercase__      =					torch_device == '''cpu'''
             lowercase__      =					True
             self._test_inference_batch_single_identical(
                 batch_size=2  ,		test_max_difference=UpperCamelCase  ,		relax_max_difference=UpperCamelCase  ,		)






      def  UpperCamelCase__						(self       :       Any					):

             '''simple docstring'''







             lowercase__      =					self.get_dummy_components()
             lowercase__      =					self.pipeline_class(**UpperCamelCase					)
             lowercase__      =					pipe.to(UpperCamelCase					)
             pipe.set_progress_bar_config(disable=UpperCamelCase					)

             lowercase__      =					1
             lowercase__      =					2

             lowercase__      =					self.get_dummy_inputs(UpperCamelCase					)

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

             lowercase__      =					pipe(**UpperCamelCase  ,		num_images_per_prompt=UpperCamelCase					)[0]

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






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





      '''simple docstring'''






      def  UpperCamelCase__						(self       :       int					):

             '''simple docstring'''







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






      def  UpperCamelCase__						(self       :       Optional[Any]					):

             '''simple docstring'''







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

             lowercase__      =					torch.Generator(device=UpperCamelCase					).manual_seed(0					)

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








'''simple docstring'''

from __future__ import annotations

from typing import Any
class     __lowerCAmelCase		:





      '''simple docstring'''






      def __init__(self       :       Optional[Any]  ,		UpperCamelCase       :       int = 6					):

             '''simple docstring'''







             lowercase__      =					None
             lowercase__      =					None
             self.create_linked_list(UpperCamelCase					)



      def  UpperCamelCase__						(self       :       List[str]  ,		UpperCamelCase       :       int					):

             '''simple docstring'''







             lowercase__      =					Node()
             lowercase__      =					current_node
             lowercase__      =					current_node
             lowercase__      =					current_node
             for _ in range(1  ,		UpperCamelCase					):
                    lowercase__      =					Node()
                    lowercase__      =					current_node
                    lowercase__      =					previous_node
                    lowercase__      =					current_node
             lowercase__      =					self.front
             lowercase__      =					previous_node



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

             '''simple docstring'''







             return (
                 self.front == self.rear
                 and self.front is not None
                 and self.front.data is None
             )



      def  UpperCamelCase__						(self       :       Dict					):

             '''simple docstring'''







             self.check_can_perform_operation()
             return self.front.data if self.front else None



      def  UpperCamelCase__						(self       :       Any  ,		UpperCamelCase       :       Any					):

             '''simple docstring'''







             if self.rear is None:
                    return

             self.check_is_full()
             if not self.is_empty():
                    lowercase__      =					self.rear.next
             if self.rear:
                    lowercase__      =					data



      def  UpperCamelCase__						(self       :       List[Any]					):

             '''simple docstring'''







             self.check_can_perform_operation()
             if self.rear is None or self.front is None:
                    return None
             if self.front == self.rear:
                    lowercase__      =					self.front.data
                    lowercase__      =					None
                    return data

             lowercase__      =					self.front
             lowercase__      =					old_front.next
             lowercase__      =					old_front.data
             lowercase__      =					None
             return data



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

             '''simple docstring'''







             if self.is_empty():
                    raise Exception('''Empty Queue'''					)






      def  UpperCamelCase__						(self       :       int					):

             '''simple docstring'''







             if self.rear and self.rear.next == self.front:
                    raise Exception('''Full Queue'''					)






class     __lowerCAmelCase		:





      '''simple docstring'''






      def __init__(self       :       Any					):

             '''simple docstring'''







             lowercase__      =					None
             lowercase__      =					None
             lowercase__      =					None


if __name__ == "__main__":
 import doctest

 doctest.testmod()




