





'''simple docstring'''

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






       """simple docstring"""
       _snake_case     :					int						    =   ShapEPipeline
       _snake_case     :					str						    =   ['prompt']
       _snake_case     :					Union[str, Any]						    =   ['prompt']
       _snake_case     :					Optional[int]						    =   [
           'num_images_per_prompt',
           'num_inference_steps',
           'generator',
           'latents',
           'guidance_scale',
           'frame_size',
           'output_type',
           'return_dict',
       ]
       _snake_case     :					List[Any]						    =   False





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

            '''simple docstring'''




            return 32





       @property
       def snake_case__						(							self       :		Tuple					)   ->					Any:

            '''simple docstring'''




            return 32





       @property
       def snake_case__						(							self       :		Optional[int]					)   ->					List[Any]:

            '''simple docstring'''




            return self.time_input_dim * 4





       @property
       def snake_case__						(							self       :		str					)   ->					Optional[Any]:

            '''simple docstring'''




            return 8





       @property
       def snake_case__						(							self       :		Tuple					)   ->					Any:

            '''simple docstring'''




            _UpperCamelCase       =	CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''					)
            return tokenizer





       @property
       def snake_case__						(							self       :		int					)   ->					int:

            '''simple docstring'''




            torch.manual_seed(0					)
            _UpperCamelCase       =	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-0_5	,			num_attention_heads=4	,			num_hidden_layers=5	,			pad_token_id=1	,			vocab_size=1000	,			)
            return CLIPTextModelWithProjection(lowerCAmelCase__					)





       @property
       def snake_case__						(							self       :		Optional[Any]					)   ->					List[Any]:

            '''simple docstring'''




            torch.manual_seed(0					)

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

            _UpperCamelCase       =	PriorTransformer(**lowerCAmelCase__					)
            return model





       @property
       def snake_case__						(							self       :		Any					)   ->					List[Any]:

            '''simple docstring'''




            torch.manual_seed(0					)

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





       def snake_case__						(							self       :		Optional[int]					)   ->					Tuple:

            '''simple docstring'''




            _UpperCamelCase       =	self.dummy_prior
            _UpperCamelCase       =	self.dummy_text_encoder
            _UpperCamelCase       =	self.dummy_tokenizer
            _UpperCamelCase       =	self.dummy_renderer

            _UpperCamelCase       =	HeunDiscreteScheduler(
                beta_schedule='''exp'''	,			num_train_timesteps=1024	,			prediction_type='''sample'''	,			use_karras_sigmas=lowerCAmelCase__	,			clip_sample=lowerCAmelCase__	,			clip_sample_range=1.0	,			)
            _UpperCamelCase       =	{
                '''prior''': prior,
                '''text_encoder''': text_encoder,
                '''tokenizer''': tokenizer,
                '''renderer''': renderer,
                '''scheduler''': scheduler,
            }

            return components





       def snake_case__						(							self       :		int	,			lowerCAmelCase__       :		Optional[Any]	,			lowerCAmelCase__       :		Union[str, Any]=0					)   ->					List[str]:

            '''simple docstring'''




            if str(lowerCAmelCase__					).startswith('''mps'''					):
                 _UpperCamelCase       =	torch.manual_seed(lowerCAmelCase__					)
            else:
                 _UpperCamelCase       =	torch.Generator(device=lowerCAmelCase__					).manual_seed(lowerCAmelCase__					)
            _UpperCamelCase       =	{
                '''prompt''': '''horse''',
                '''generator''': generator,
                '''num_inference_steps''': 1,
                '''frame_size''': 32,
                '''output_type''': '''np''',
            }
            return inputs





       def snake_case__						(							self       :		int					)   ->					int:

            '''simple docstring'''




            _UpperCamelCase       =	'''cpu'''

            _UpperCamelCase       =	self.get_dummy_components()

            _UpperCamelCase       =	self.pipeline_class(**lowerCAmelCase__					)
            _UpperCamelCase       =	pipe.to(lowerCAmelCase__					)

            pipe.set_progress_bar_config(disable=lowerCAmelCase__					)

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

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

            _UpperCamelCase       =	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 snake_case__						(							self       :		Any					)   ->					Dict:

            '''simple docstring'''




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





       def snake_case__						(							self       :		Tuple					)   ->					Tuple:

            '''simple docstring'''




            _UpperCamelCase       =	torch_device == '''cpu'''
            _UpperCamelCase       =	True

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







       def snake_case__						(							self       :		str					)   ->					List[str]:

            '''simple docstring'''




            _UpperCamelCase       =	self.get_dummy_components()
            _UpperCamelCase       =	self.pipeline_class(**lowerCAmelCase__					)
            _UpperCamelCase       =	pipe.to(lowerCAmelCase__					)
            pipe.set_progress_bar_config(disable=lowerCAmelCase__					)

            _UpperCamelCase       =	1
            _UpperCamelCase       =	2

            _UpperCamelCase       =	self.get_dummy_inputs(lowerCAmelCase__					)

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

            _UpperCamelCase       =	pipe(**lowerCAmelCase__	,			num_images_per_prompt=lowerCAmelCase__					)[0]

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

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






       """simple docstring"""





       def snake_case__						(							self       :		Optional[Any]					)   ->					List[str]:

            '''simple docstring'''




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







       def snake_case__						(							self       :		List[Any]					)   ->					Dict:

            '''simple docstring'''




            _UpperCamelCase       =	load_numpy(
                '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
                '''/shap_e/test_shap_e_np_out.npy'''					)
            _UpperCamelCase       =	ShapEPipeline.from_pretrained('''openai/shap-e'''					)
            _UpperCamelCase       =	pipe.to(lowerCAmelCase__					)
            pipe.set_progress_bar_config(disable=lowerCAmelCase__					)

            _UpperCamelCase       =	torch.Generator(device=lowerCAmelCase__					).manual_seed(0					)

            _UpperCamelCase       =	pipe(
                '''a shark'''	,			generator=lowerCAmelCase__	,			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(lowerCAmelCase__	,			lowerCAmelCase__					)










'''simple docstring'''

import warnings

from ...utils import logging
from .image_processing_owlvit import OwlViTImageProcessor


lowercase__						:      Optional[Any]	=    logging.get_logger(__name__)
class     __lowerCAmelCase					(   __magic_name__			):






       """simple docstring"""





       def __init__(							self       :		List[Any]	,			*lowerCAmelCase__       :		List[str]	,			**lowerCAmelCase__       :		List[str]					)   ->					None:

            '''simple docstring'''




            warnings.warn(
                '''The class OwlViTFeatureExtractor is deprecated and will be removed in version 5 of Transformers. Please'''
                ''' use OwlViTImageProcessor instead.'''	,			lowerCAmelCase__	,			)
            super().__init__(*lowerCAmelCase__	,			**lowerCAmelCase__					)



