import copy
import os
from typing import Union

from ...configuration_utils import PretrainedConfig
from ...utils import logging


A						=			logging.get_logger(__name__)

A						=			{
    'BAAI/AltCLIP': 'https://huggingface.co/BAAI/AltCLIP/resolve/main/config.json',
    # See all AltCLIP models at https://huggingface.co/models?filter=altclip
}





class     lowerCAmelCase__     (				SCREAMING_SNAKE_CASE_			):


		'''simple docstring'''






		lowerCAmelCase_     =   'altclip_text_model'
		def __init__(       self     :     Optional[Any]     ,  snake_case__     :     Optional[int]=2_5_0_0_0_2     ,  snake_case__     :     Optional[Any]=1_0_2_4     ,  snake_case__     :     List[str]=2_4     ,  snake_case__     :     List[str]=1_6     ,  snake_case__     :     int=4_0_9_6     ,  snake_case__     :     Union[str, Any]="gelu"     ,  snake_case__     :     int=0.1     ,  snake_case__     :     str=0.1     ,  snake_case__     :     Dict=5_1_4     ,  snake_case__     :     List[str]=1     ,  snake_case__     :     Union[str, Any]=0.02     ,  snake_case__     :     List[str]=0.02     ,  snake_case__     :     int=1e-05     ,  snake_case__     :     Any=1     ,  snake_case__     :     List[str]=0     ,  snake_case__     :     Tuple=2     ,  snake_case__     :     Union[str, Any]="absolute"     ,  snake_case__     :     Tuple=True     ,  snake_case__     :     Union[str, Any]=7_6_8     ,  **snake_case__     :     Tuple     ,  )      ->	Union[str, Any]:
				super().__init__(pad_token_id=snake_case__     ,  bos_token_id=snake_case__     ,  eos_token_id=snake_case__     ,  **snake_case__		)

				_lowerCamelCase				   =  vocab_size
				_lowerCamelCase				   =  hidden_size
				_lowerCamelCase				   =  num_hidden_layers
				_lowerCamelCase				   =  num_attention_heads
				_lowerCamelCase				   =  hidden_act
				_lowerCamelCase				   =  intermediate_size
				_lowerCamelCase				   =  hidden_dropout_prob
				_lowerCamelCase				   =  attention_probs_dropout_prob
				_lowerCamelCase				   =  max_position_embeddings
				_lowerCamelCase				   =  type_vocab_size
				_lowerCamelCase				   =  initializer_range
				_lowerCamelCase				   =  initializer_factor
				_lowerCamelCase				   =  layer_norm_eps
				_lowerCamelCase				   =  position_embedding_type
				_lowerCamelCase				   =  use_cache
				_lowerCamelCase				   =  project_dim





class     lowerCAmelCase__     (				SCREAMING_SNAKE_CASE_			):


		'''simple docstring'''






		lowerCAmelCase_     =   'altclip_vision_model'
		def __init__(       self     :     Optional[Any]     ,  snake_case__     :     int=7_6_8     ,  snake_case__     :     Any=3_0_7_2     ,  snake_case__     :     Optional[int]=5_1_2     ,  snake_case__     :     Any=1_2     ,  snake_case__     :     List[Any]=1_2     ,  snake_case__     :     Any=3     ,  snake_case__     :     Optional[int]=2_2_4     ,  snake_case__     :     Any=3_2     ,  snake_case__     :     Optional[Any]="quick_gelu"     ,  snake_case__     :     Union[str, Any]=1e-5     ,  snake_case__     :     str=0.0     ,  snake_case__     :     Dict=0.02     ,  snake_case__     :     List[str]=1.0     ,  **snake_case__     :     Union[str, Any]     ,  )      ->	Dict:
				super().__init__(**snake_case__		)

				_lowerCamelCase				   =  hidden_size
				_lowerCamelCase				   =  intermediate_size
				_lowerCamelCase				   =  projection_dim
				_lowerCamelCase				   =  num_hidden_layers
				_lowerCamelCase				   =  num_attention_heads
				_lowerCamelCase				   =  num_channels
				_lowerCamelCase				   =  patch_size
				_lowerCamelCase				   =  image_size
				_lowerCamelCase				   =  initializer_range
				_lowerCamelCase				   =  initializer_factor
				_lowerCamelCase				   =  attention_dropout
				_lowerCamelCase				   =  layer_norm_eps
				_lowerCamelCase				   =  hidden_act



		@classmethod
		def   _snake_case       (       cls     :     List[Any]     ,  snake_case__     :     Union[str, os.PathLike]     ,  **snake_case__     :     str		)      ->	"PretrainedConfig":
				cls._set_token_in_kwargs(snake_case__		)

				_lowerCamelCase   ,							_lowerCamelCase				   =  cls.get_config_dict(snake_case__     ,  **snake_case__		)

				# get the vision config dict if we are loading from AltCLIPConfig
				if config_dict.get('model_type'		) == "altclip":
						_lowerCamelCase				   =  config_dict['vision_config']

				if "model_type" in config_dict and hasattr(cls     ,  'model_type'		) and config_dict["model_type"] != cls.model_type:
						logger.warning(
						    f"""You are using a model of type {config_dict["model_type"]} to instantiate a model of type """
						    f"""{cls.model_type}. This is not supported for all configurations of models and can yield errors."""		)

				return cls.from_dict(snake_case__     ,  **snake_case__		)





class     lowerCAmelCase__     (				SCREAMING_SNAKE_CASE_			):


		'''simple docstring'''






		lowerCAmelCase_     =   'altclip'
		lowerCAmelCase_     =   True
		def __init__(       self     :     str     ,  snake_case__     :     Optional[Any]=None     ,  snake_case__     :     Union[str, Any]=None     ,  snake_case__     :     Optional[int]=7_6_8     ,  snake_case__     :     List[Any]=2.6592     ,  **snake_case__     :     Any		)      ->	Dict:
				# If `_config_dict` exist, we use them for the backward compatibility.
				# We pop out these 2 attributes before calling `super().__init__` to avoid them being saved (which causes a lot
				# of confusion!).
				_lowerCamelCase				   =  kwargs.pop('text_config_dict'     ,  snake_case__		)
				_lowerCamelCase				   =  kwargs.pop('vision_config_dict'     ,  snake_case__		)

				super().__init__(**snake_case__		)

				# Instead of simply assigning `[text|vision]_config_dict` to `[text|vision]_config`, we use the values in
				# `[text|vision]_config_dict` to update the values in `[text|vision]_config`. The values should be same in most
				# cases, but we don't want to break anything regarding `_config_dict` that existed before commit `8827e1b2`.
				if text_config_dict is not None:
						if text_config is None:
								_lowerCamelCase				   =  {}

						# This is the complete result when using `text_config_dict`.
						_lowerCamelCase				   =  AltCLIPTextConfig(**snake_case__		).to_dict()

						# Give a warning if the values exist in both `_text_config_dict` and `text_config` but being different.
						for key, value in _text_config_dict.items():
								if key in text_config and value != text_config[key] and key not in ["transformers_version"]:
										# If specified in `text_config_dict`
										if key in text_config_dict:
												_lowerCamelCase				   =  (
												    f"""`{key}` is found in both `text_config_dict` and `text_config` but with different values. """
												    f"""The value `text_config_dict[\"{key}\"]` will be used instead."""
												)
										# If inferred from default argument values (just to be super careful)
										else:
												_lowerCamelCase				   =  (
												    f"""`text_config_dict` is provided which will be used to initialize `AltCLIPTextConfig`. The """
												    f"""value `text_config[\"{key}\"]` will be overriden."""
												)
										logger.warning(snake_case__		)

            # Update all values in `text_config` with the ones in `_text_config_dict`.
						text_config.update(_text_config_dict		)

				if vision_config_dict is not None:
						if vision_config is None:
								_lowerCamelCase				   =  {}

						# This is the complete result when using `vision_config_dict`.
						_lowerCamelCase				   =  AltCLIPVisionConfig(**snake_case__		).to_dict()
						# convert keys to string instead of integer
						if "id2label" in _vision_config_dict:
								_lowerCamelCase				   =  {
								    str(snake_case__		): value for key, value in _vision_config_dict['id2label'].items()
								}

						# Give a warning if the values exist in both `_vision_config_dict` and `vision_config` but being different.
						for key, value in _vision_config_dict.items():
								if key in vision_config and value != vision_config[key] and key not in ["transformers_version"]:
										# If specified in `vision_config_dict`
										if key in vision_config_dict:
												_lowerCamelCase				   =  (
												    f"""`{key}` is found in both `vision_config_dict` and `vision_config` but with different """
												    f"""values. The value `vision_config_dict[\"{key}\"]` will be used instead."""
												)
										# If inferred from default argument values (just to be super careful)
										else:
												_lowerCamelCase				   =  (
												    f"""`vision_config_dict` is provided which will be used to initialize `AltCLIPVisionConfig`. """
												    f"""The value `vision_config[\"{key}\"]` will be overriden."""
												)
										logger.warning(snake_case__		)

            # Update all values in `vision_config` with the ones in `_vision_config_dict`.
						vision_config.update(_vision_config_dict		)

				if text_config is None:
						_lowerCamelCase				   =  {}
						logger.info('`text_config` is `None`. Initializing the `AltCLIPTextConfig` with default values.'		)

				if vision_config is None:
						_lowerCamelCase				   =  {}
						logger.info('`vision_config` is `None`. initializing the `AltCLIPVisionConfig` with default values.'		)

				_lowerCamelCase				   =  AltCLIPTextConfig(**snake_case__		)
				_lowerCamelCase				   =  AltCLIPVisionConfig(**snake_case__		)

				_lowerCamelCase				   =  projection_dim
				_lowerCamelCase				   =  logit_scale_init_value
				_lowerCamelCase				   =  1.0
		@classmethod
		def   _snake_case       (       cls     :     Optional[Any]     ,  snake_case__     :     AltCLIPTextConfig     ,  snake_case__     :     AltCLIPVisionConfig     ,  **snake_case__     :     List[str]		)      ->	Optional[Any]:
				return cls(text_config=text_config.to_dict()     ,  vision_config=vision_config.to_dict()     ,  **snake_case__		)



		def   _snake_case       (       self     :     int		)      ->	Tuple:
				_lowerCamelCase				   =  copy.deepcopy(self.__dict__		)
				_lowerCamelCase				   =  self.text_config.to_dict()
				_lowerCamelCase				   =  self.vision_config.to_dict()
				_lowerCamelCase				   =  self.__class__.model_type
				return output
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__     (				SCREAMING_SNAKE_CASE_     ,unittest.TestCase			):


		'''simple docstring'''






		lowerCAmelCase_     =   ShapEImgaImgPipeline
		lowerCAmelCase_     =   ['image']
		lowerCAmelCase_     =   ['image']
		lowerCAmelCase_     =   [
		    'num_images_per_prompt',
		    'num_inference_steps',
		    'generator',
		    'latents',
		    'guidance_scale',
		    'frame_size',
		    'output_type',
		    'return_dict',
		]
		lowerCAmelCase_     =   False
		@property
		def   _snake_case       (       self     :     List[str]		)      ->	Any:
				return 3_2
		@property
		def   _snake_case       (       self     :     int		)      ->	Dict:
				return 3_2
		@property
		def   _snake_case       (       self     :     Tuple		)      ->	Optional[Any]:
				return self.time_input_dim * 4
		@property
		def   _snake_case       (       self     :     Tuple		)      ->	Optional[Any]:
				return 8
		@property
		def   _snake_case       (       self     :     int		)      ->	Dict:
				torch.manual_seed(0		)
				_lowerCamelCase				   =  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     ,  )

				_lowerCamelCase				   =  CLIPVisionModel(snake_case__		)
				return model
		@property
		def   _snake_case       (       self     :     Tuple		)      ->	Any:
				_lowerCamelCase				   =  CLIPImageProcessor(
				    crop_size=2_2_4     ,  do_center_crop=snake_case__     ,  do_normalize=snake_case__     ,  do_resize=snake_case__     ,  image_mean=[0.4814_5466, 0.457_8275, 0.4082_1073]     ,  image_std=[0.2686_2954, 0.2613_0258, 0.2757_7711]     ,  resample=3     ,  size=2_2_4     ,  )

				return image_processor
		@property
		def   _snake_case       (       self     :     List[str]		)      ->	Any:
				torch.manual_seed(0		)

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

				_lowerCamelCase				   =  PriorTransformer(**snake_case__		)
				return model
		@property
		def   _snake_case       (       self     :     List[Any]		)      ->	Optional[int]:
				torch.manual_seed(0		)

				_lowerCamelCase				   =  {
				    '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,
				    ),
				}
				_lowerCamelCase				   =  ShapERenderer(**snake_case__		)
				return model
		def   _snake_case       (       self     :     Any		)      ->	str:
				_lowerCamelCase				   =  self.dummy_prior
				_lowerCamelCase				   =  self.dummy_image_encoder
				_lowerCamelCase				   =  self.dummy_image_processor
				_lowerCamelCase				   =  self.dummy_renderer

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

				return components
		def   _snake_case       (       self     :     List[str]     ,  snake_case__     :     str     ,  snake_case__     :     Optional[Any]=0		)      ->	Union[str, Any]:
				_lowerCamelCase				   =  floats_tensor((1, 3, 6_4, 6_4)     ,  rng=random.Random(snake_case__		)		).to(snake_case__		)

				if str(snake_case__		).startswith('mps'		):
						_lowerCamelCase				   =  torch.manual_seed(snake_case__		)
				else:
						_lowerCamelCase				   =  torch.Generator(device=snake_case__		).manual_seed(snake_case__		)
				_lowerCamelCase				   =  {
				    'image': input_image,
				    'generator': generator,
				    'num_inference_steps': 1,
				    'frame_size': 3_2,
				    'output_type': 'np',
				}
				return inputs
		def   _snake_case       (       self     :     Union[str, Any]		)      ->	Union[str, Any]:
				_lowerCamelCase				   =  'cpu'

				_lowerCamelCase				   =  self.get_dummy_components()

				_lowerCamelCase				   =  self.pipeline_class(**snake_case__		)
				_lowerCamelCase				   =  pipe.to(snake_case__		)

				pipe.set_progress_bar_config(disable=snake_case__		)

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

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

				_lowerCamelCase				   =  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   _snake_case       (       self     :     Dict		)      ->	Optional[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   _snake_case       (       self     :     Optional[Any]		)      ->	Tuple:
				_lowerCamelCase				   =  torch_device == 'cpu'
				_lowerCamelCase				   =  True
				self._test_inference_batch_single_identical(
				    batch_size=2     ,  test_max_difference=snake_case__     ,  relax_max_difference=snake_case__     ,  )



		def   _snake_case       (       self     :     Any		)      ->	Tuple:
				_lowerCamelCase				   =  self.get_dummy_components()
				_lowerCamelCase				   =  self.pipeline_class(**snake_case__		)
				_lowerCamelCase				   =  pipe.to(snake_case__		)
				pipe.set_progress_bar_config(disable=snake_case__		)

				_lowerCamelCase				   =  1
				_lowerCamelCase				   =  2

				_lowerCamelCase				   =  self.get_dummy_inputs(snake_case__		)

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

				_lowerCamelCase				   =  pipe(**snake_case__     ,  num_images_per_prompt=snake_case__		)[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     :     Union[str, Any]		)      ->	Optional[int]:
				# clean up the VRAM after each test
				super().tearDown()
				gc.collect()
				torch.cuda.empty_cache()



		def   _snake_case       (       self     :     List[str]		)      ->	List[Any]:
				_lowerCamelCase				   =  load_image(
				    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/shap_e/corgi.png'		)
				_lowerCamelCase				   =  load_numpy(
				    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
				    '/shap_e/test_shap_e_img2img_out.npy'		)
				_lowerCamelCase				   =  ShapEImgaImgPipeline.from_pretrained('openai/shap-e-img2img'		)
				_lowerCamelCase				   =  pipe.to(snake_case__		)
				pipe.set_progress_bar_config(disable=snake_case__		)

				_lowerCamelCase				   =  torch.Generator(device=snake_case__		).manual_seed(0		)

				_lowerCamelCase				   =  pipe(
				    snake_case__     ,  generator=snake_case__     ,  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(snake_case__     ,  snake_case__		)