





import inspect
from typing import Callable, List, Optional, Union

import torch
from transformers import CLIPImageProcessor, CLIPTextModel, CLIPTokenizer

from diffusers import DiffusionPipeline
from diffusers.models import AutoencoderKL, UNetaDConditionModel
from diffusers.pipelines.stable_diffusion import StableDiffusionPipelineOutput
from diffusers.pipelines.stable_diffusion.safety_checker import StableDiffusionSafetyChecker
from diffusers.schedulers import DDIMScheduler, LMSDiscreteScheduler, PNDMScheduler
from diffusers.utils import logging


lowerCAmelCase							:       List[str]					 =	logging.get_logger(__name__)  # pylint: disable=invalid-name





class 				a			(      __lowercase			):






				def __init__(  self			, _lowerCAmelCase			, _lowerCAmelCase			, _lowerCAmelCase			, _lowerCAmelCase			, _lowerCAmelCase			, _lowerCAmelCase			, _lowerCAmelCase			, ):

										"""simple docstring"""




										super().__init__()
										self.register_modules(
										    vae=_lowerCAmelCase			, text_encoder=_lowerCAmelCase			, tokenizer=_lowerCAmelCase			, unet=_lowerCAmelCase			, scheduler=_lowerCAmelCase			, safety_checker=_lowerCAmelCase			, feature_extractor=_lowerCAmelCase			, )






				def 			snake_case_    (  self			, _lowerCAmelCase = "auto"					):

										"""simple docstring"""




										if slice_size == "auto":
																# half the attention head size is usually a good trade-off between
																# speed and memory
																__SCREAMING_SNAKE_CASE:				Union[str, Any]           =   self.unet.config.attention_head_dim // 2
										self.unet.set_attention_slice(_lowerCAmelCase					)






				def 			snake_case_    (  self					):

										"""simple docstring"""




										self.enable_attention_slicing(_lowerCAmelCase					)






				@torch.no_grad()
				def __call__(  self			, _lowerCAmelCase			, _lowerCAmelCase = 512			, _lowerCAmelCase = 512			, _lowerCAmelCase = 50			, _lowerCAmelCase = 7.5			, _lowerCAmelCase = None			, _lowerCAmelCase = 1			, _lowerCAmelCase = 0.0			, _lowerCAmelCase = None			, _lowerCAmelCase = None			, _lowerCAmelCase = "pil"			, _lowerCAmelCase = True			, _lowerCAmelCase = None			, _lowerCAmelCase = 1			, _lowerCAmelCase = None			, **_lowerCAmelCase			, ):

										"""simple docstring"""




										if isinstance(_lowerCAmelCase			, _lowerCAmelCase					):
																__SCREAMING_SNAKE_CASE:				List[Any]           =   1
										elif isinstance(_lowerCAmelCase			, _lowerCAmelCase					):
																__SCREAMING_SNAKE_CASE:				Tuple           =   len(_lowerCAmelCase					)
										else:
																raise ValueError(f"""`prompt` has to be of type `str` or `list` but is {type(_lowerCAmelCase					)}"""					)

										if height % 8 != 0 or width % 8 != 0:
																raise ValueError(f"""`height` and `width` have to be divisible by 8 but are {height} and {width}."""					)

										if (callback_steps is None) or (
										    callback_steps is not None and (not isinstance(_lowerCAmelCase			, _lowerCAmelCase					) or callback_steps <= 0)
										):
																raise ValueError(
																    f"""`callback_steps` has to be a positive integer but is {callback_steps} of type"""
																    f""" {type(_lowerCAmelCase					)}."""					)

										# get prompt text embeddings
										__SCREAMING_SNAKE_CASE:				List[str]           =   self.tokenizer(
										    _lowerCAmelCase			, padding='''max_length'''			, max_length=self.tokenizer.model_max_length			, return_tensors='''pt'''			, )
										__SCREAMING_SNAKE_CASE:				List[Any]           =   text_inputs.input_ids

										if text_input_ids.shape[-1] > self.tokenizer.model_max_length:
																__SCREAMING_SNAKE_CASE:				Tuple           =   self.tokenizer.batch_decode(text_input_ids[:, self.tokenizer.model_max_length :]					)
																logger.warning(
																    '''The following part of your input was truncated because CLIP can only handle sequences up to'''
																    f""" {self.tokenizer.model_max_length} tokens: {removed_text}"""					)
																__SCREAMING_SNAKE_CASE:				Union[str, Any]           =   text_input_ids[:, : self.tokenizer.model_max_length]

										if text_embeddings is None:
																__SCREAMING_SNAKE_CASE:				Optional[Any]           =   self.text_encoder(text_input_ids.to(self.device					)					)[0]

										# duplicate text embeddings for each generation per prompt, using mps friendly method
										__SCREAMING_SNAKE_CASE       ,__SCREAMING_SNAKE_CASE       ,__SCREAMING_SNAKE_CASE:				str           =   text_embeddings.shape
										__SCREAMING_SNAKE_CASE:				Any           =   text_embeddings.repeat(1			, _lowerCAmelCase			, 1					)
										__SCREAMING_SNAKE_CASE:				Optional[int]           =   text_embeddings.view(bs_embed * num_images_per_prompt			, _lowerCAmelCase			, -1					)

										# here `guidance_scale` is defined analog to the guidance weight `w` of equation (2)
										# of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1`
										# corresponds to doing no classifier free guidance.
										__SCREAMING_SNAKE_CASE:				str           =   guidance_scale > 1.0
										# get unconditional embeddings for classifier free guidance
										if do_classifier_free_guidance:
																__SCREAMING_SNAKE_CASE:				List[str]
																if negative_prompt is None:
																						__SCREAMING_SNAKE_CASE:				List[str]           =   ['''''']
																elif type(_lowerCAmelCase					) is not type(_lowerCAmelCase					):
																						raise TypeError(
																						    f"""`negative_prompt` should be the same type to `prompt`, but got {type(_lowerCAmelCase					)} !="""
																						    f""" {type(_lowerCAmelCase					)}."""					)
																elif isinstance(_lowerCAmelCase			, _lowerCAmelCase					):
																						__SCREAMING_SNAKE_CASE:				Tuple           =   [negative_prompt]
																elif batch_size != len(_lowerCAmelCase					):
																						raise ValueError(
																						    f"""`negative_prompt`: {negative_prompt} has batch size {len(_lowerCAmelCase					)}, but `prompt`:"""
																						    f""" {prompt} has batch size {batch_size}. Please make sure that passed `negative_prompt` matches"""
																						    ''' the batch size of `prompt`.'''					)
																else:
																						__SCREAMING_SNAKE_CASE:				Tuple           =   negative_prompt

																__SCREAMING_SNAKE_CASE:				Optional[Any]           =   text_input_ids.shape[-1]
																__SCREAMING_SNAKE_CASE:				Union[str, Any]           =   self.tokenizer(
																    _lowerCAmelCase			, padding='''max_length'''			, max_length=_lowerCAmelCase			, truncation=_lowerCAmelCase			, return_tensors='''pt'''			, )
																__SCREAMING_SNAKE_CASE:				List[Any]           =   self.text_encoder(uncond_input.input_ids.to(self.device					)					)[0]

																# duplicate unconditional embeddings for each generation per prompt, using mps friendly method
																__SCREAMING_SNAKE_CASE:				Dict           =   uncond_embeddings.shape[1]
																__SCREAMING_SNAKE_CASE:				List[str]           =   uncond_embeddings.repeat(_lowerCAmelCase			, _lowerCAmelCase			, 1					)
																__SCREAMING_SNAKE_CASE:				List[str]           =   uncond_embeddings.view(batch_size * num_images_per_prompt			, _lowerCAmelCase			, -1					)

																# For classifier free guidance, we need to do two forward passes.
																# Here we concatenate the unconditional and text embeddings into a single batch
																# to avoid doing two forward passes
																__SCREAMING_SNAKE_CASE:				List[Any]           =   torch.cat([uncond_embeddings, text_embeddings]					)

										# get the initial random noise unless the user supplied it

										# Unlike in other pipelines, latents need to be generated in the target device
										# for 1-to-1 results reproducibility with the CompVis implementation.
										# However this currently doesn't work in `mps`.
										__SCREAMING_SNAKE_CASE:				List[Any]           =   (batch_size * num_images_per_prompt, self.unet.config.in_channels, height // 8, width // 8)
										__SCREAMING_SNAKE_CASE:				List[str]           =   (batch_size * num_images_per_prompt, self.unet.config.in_channels, 64, 64)
										__SCREAMING_SNAKE_CASE:				Dict           =   text_embeddings.dtype
										if latents is None:
																if self.device.type == "mps":
																						# randn does not exist on mps
																						__SCREAMING_SNAKE_CASE:				List[str]           =   torch.randn(
																						    _lowerCAmelCase			, generator=_lowerCAmelCase			, device='''cpu'''			, dtype=_lowerCAmelCase					).to(self.device					)
																						__SCREAMING_SNAKE_CASE:				int           =   torch.randn(_lowerCAmelCase			, generator=_lowerCAmelCase			, device='''cpu'''			, dtype=_lowerCAmelCase					).to(
																						    self.device					)
																else:
																						__SCREAMING_SNAKE_CASE:				Optional[Any]           =   torch.randn(
																						    _lowerCAmelCase			, generator=_lowerCAmelCase			, device=self.device			, dtype=_lowerCAmelCase					)
																						__SCREAMING_SNAKE_CASE:				Optional[Any]           =   torch.randn(_lowerCAmelCase			, generator=_lowerCAmelCase			, device=self.device			, dtype=_lowerCAmelCase					)
										else:
																if latents_reference.shape != latents_shape:
																						raise ValueError(f"""Unexpected latents shape, got {latents.shape}, expected {latents_shape}"""					)
																__SCREAMING_SNAKE_CASE:				Optional[Any]           =   latents_reference.to(self.device					)
																__SCREAMING_SNAKE_CASE:				List[str]           =   latents.to(self.device					)

										# This is the key part of the pipeline where we
										# try to ensure that the generated images w/ the same seed
										# but different sizes actually result in similar images
										__SCREAMING_SNAKE_CASE:				int           =   (latents_shape[3] - latents_shape_reference[3]) // 2
										__SCREAMING_SNAKE_CASE:				Tuple           =   (latents_shape[2] - latents_shape_reference[2]) // 2
										__SCREAMING_SNAKE_CASE:				List[Any]           =   latents_shape_reference[3] if dx >= 0 else latents_shape_reference[3] + 2 * dx
										__SCREAMING_SNAKE_CASE:				str           =   latents_shape_reference[2] if dy >= 0 else latents_shape_reference[2] + 2 * dy
										__SCREAMING_SNAKE_CASE:				Optional[Any]           =   0 if dx < 0 else dx
										__SCREAMING_SNAKE_CASE:				Dict           =   0 if dy < 0 else dy
										__SCREAMING_SNAKE_CASE:				str           =   max(-dx			, 0					)
										__SCREAMING_SNAKE_CASE:				Optional[Any]           =   max(-dy			, 0					)
										# import pdb
										# pdb.set_trace()
										__SCREAMING_SNAKE_CASE:				Union[str, Any]           =   latents_reference[:, :, dy : dy + h, dx : dx + w]

										# set timesteps
										self.scheduler.set_timesteps(_lowerCAmelCase					)

										# Some schedulers like PNDM have timesteps as arrays
										# It's more optimized to move all timesteps to correct device beforehand
										__SCREAMING_SNAKE_CASE:				List[str]           =   self.scheduler.timesteps.to(self.device					)

										# scale the initial noise by the standard deviation required by the scheduler
										__SCREAMING_SNAKE_CASE:				Union[str, Any]           =   latents * self.scheduler.init_noise_sigma

										# prepare extra kwargs for the scheduler step, since not all schedulers have the same signature
										# eta (η) is only used with the DDIMScheduler, it will be ignored for other schedulers.
										# eta corresponds to η in DDIM paper: https://arxiv.org/abs/2010.02502
										# and should be between [0, 1]
										__SCREAMING_SNAKE_CASE:				Dict           =   '''eta''' in set(inspect.signature(self.scheduler.step					).parameters.keys()					)
										__SCREAMING_SNAKE_CASE:				int           =   {}
										if accepts_eta:
																__SCREAMING_SNAKE_CASE:				Dict           =   eta

										for i, t in enumerate(self.progress_bar(_lowerCAmelCase					)					):
																# expand the latents if we are doing classifier free guidance
																__SCREAMING_SNAKE_CASE:				Optional[Any]           =   torch.cat([latents] * 2					) if do_classifier_free_guidance else latents
																__SCREAMING_SNAKE_CASE:				int           =   self.scheduler.scale_model_input(_lowerCAmelCase			, _lowerCAmelCase					)

																# predict the noise residual
																__SCREAMING_SNAKE_CASE:				str           =   self.unet(_lowerCAmelCase			, _lowerCAmelCase			, encoder_hidden_states=_lowerCAmelCase					).sample

																# perform guidance
																if do_classifier_free_guidance:
																						__SCREAMING_SNAKE_CASE       ,__SCREAMING_SNAKE_CASE:				Tuple           =   noise_pred.chunk(2					)
																						__SCREAMING_SNAKE_CASE:				int           =   noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)

																# compute the previous noisy sample x_t -> x_t-1
																__SCREAMING_SNAKE_CASE:				Tuple           =   self.scheduler.step(_lowerCAmelCase			, _lowerCAmelCase			, _lowerCAmelCase			, **_lowerCAmelCase					).prev_sample

																# call the callback, if provided
																if callback is not None and i % callback_steps == 0:
																						callback(_lowerCAmelCase			, _lowerCAmelCase			, _lowerCAmelCase					)

										__SCREAMING_SNAKE_CASE:				Any           =   1 / 0.18215 * latents
										__SCREAMING_SNAKE_CASE:				Tuple           =   self.vae.decode(_lowerCAmelCase					).sample

										__SCREAMING_SNAKE_CASE:				Tuple           =   (image / 2 + 0.5).clamp(0			, 1					)

										# we always cast to float32 as this does not cause significant overhead and is compatible with bfloat16
										__SCREAMING_SNAKE_CASE:				Tuple           =   image.cpu().permute(0			, 2			, 3			, 1					).float().numpy()

										if self.safety_checker is not None:
																__SCREAMING_SNAKE_CASE:				str           =   self.feature_extractor(self.numpy_to_pil(_lowerCAmelCase					)			, return_tensors='''pt'''					).to(
																    self.device					)
																__SCREAMING_SNAKE_CASE       ,__SCREAMING_SNAKE_CASE:				Optional[int]           =   self.safety_checker(
																    images=_lowerCAmelCase			, clip_input=safety_checker_input.pixel_values.to(text_embeddings.dtype					)					)
										else:
																__SCREAMING_SNAKE_CASE:				List[str]           =   None

										if output_type == "pil":
																__SCREAMING_SNAKE_CASE:				List[str]           =   self.numpy_to_pil(_lowerCAmelCase					)

										if not return_dict:
																return (image, has_nsfw_concept)

										return StableDiffusionPipelineOutput(images=_lowerCAmelCase			, nsfw_content_detected=_lowerCAmelCase					)










from collections import OrderedDict
from typing import Mapping

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


lowerCAmelCase							:       Optional[int]					 =	logging.get_logger(__name__)

lowerCAmelCase							:       Tuple					 =	{
    """facebook/data2vec-vision-base-ft""": (
        """https://huggingface.co/facebook/data2vec-vision-base-ft/resolve/main/config.json"""
    ),
}





class 				a			(      __lowercase			):
				SCREAMING_SNAKE_CASE__     :   Union[str, Any]		      =     '''data2vec-vision'''






				def __init__(  self			, _lowerCAmelCase=768			, _lowerCAmelCase=12			, _lowerCAmelCase=12			, _lowerCAmelCase=3072			, _lowerCAmelCase="gelu"			, _lowerCAmelCase=0.0			, _lowerCAmelCase=0.0			, _lowerCAmelCase=0.02			, _lowerCAmelCase=1e-12			, _lowerCAmelCase=224			, _lowerCAmelCase=16			, _lowerCAmelCase=3			, _lowerCAmelCase=False			, _lowerCAmelCase=False			, _lowerCAmelCase=False			, _lowerCAmelCase=False			, _lowerCAmelCase=0.1			, _lowerCAmelCase=0.1			, _lowerCAmelCase=True			, _lowerCAmelCase=[3, 5, 7, 11]			, _lowerCAmelCase=[1, 2, 3, 6]			, _lowerCAmelCase=True			, _lowerCAmelCase=0.4			, _lowerCAmelCase=256			, _lowerCAmelCase=1			, _lowerCAmelCase=False			, _lowerCAmelCase=255			, **_lowerCAmelCase			, ):

										"""simple docstring"""




										super().__init__(**_lowerCAmelCase					)

										__SCREAMING_SNAKE_CASE:				str           =   hidden_size
										__SCREAMING_SNAKE_CASE:				Tuple           =   num_hidden_layers
										__SCREAMING_SNAKE_CASE:				Tuple           =   num_attention_heads
										__SCREAMING_SNAKE_CASE:				int           =   intermediate_size
										__SCREAMING_SNAKE_CASE:				Optional[Any]           =   hidden_act
										__SCREAMING_SNAKE_CASE:				int           =   hidden_dropout_prob
										__SCREAMING_SNAKE_CASE:				str           =   attention_probs_dropout_prob
										__SCREAMING_SNAKE_CASE:				Any           =   initializer_range
										__SCREAMING_SNAKE_CASE:				Union[str, Any]           =   layer_norm_eps

										__SCREAMING_SNAKE_CASE:				Optional[Any]           =   image_size
										__SCREAMING_SNAKE_CASE:				List[str]           =   patch_size
										__SCREAMING_SNAKE_CASE:				Optional[int]           =   num_channels
										__SCREAMING_SNAKE_CASE:				List[Any]           =   use_mask_token
										__SCREAMING_SNAKE_CASE:				Tuple           =   use_absolute_position_embeddings
										__SCREAMING_SNAKE_CASE:				Any           =   use_relative_position_bias
										__SCREAMING_SNAKE_CASE:				Dict           =   use_shared_relative_position_bias
										__SCREAMING_SNAKE_CASE:				Any           =   layer_scale_init_value
										__SCREAMING_SNAKE_CASE:				List[Any]           =   drop_path_rate
										__SCREAMING_SNAKE_CASE:				int           =   use_mean_pooling
										# decode head attributes (semantic segmentation)
										__SCREAMING_SNAKE_CASE:				Union[str, Any]           =   out_indices
										__SCREAMING_SNAKE_CASE:				Optional[int]           =   pool_scales
										# auxiliary head attributes (semantic segmentation)
										__SCREAMING_SNAKE_CASE:				Optional[int]           =   use_auxiliary_head
										__SCREAMING_SNAKE_CASE:				Optional[Any]           =   auxiliary_loss_weight
										__SCREAMING_SNAKE_CASE:				Optional[Any]           =   auxiliary_channels
										__SCREAMING_SNAKE_CASE:				Optional[int]           =   auxiliary_num_convs
										__SCREAMING_SNAKE_CASE:				Any           =   auxiliary_concat_input
										__SCREAMING_SNAKE_CASE:				List[str]           =   semantic_loss_ignore_index





class 				a			(      __lowercase			):
				SCREAMING_SNAKE_CASE__     :   List[Any]		      =     version.parse('''1.11'''			)






				@property
				def 			snake_case_    (  self					):

										"""simple docstring"""




										return OrderedDict(
										    [
										        ('''pixel_values''', {0: '''batch''', 1: '''num_channels''', 2: '''height''', 3: '''width'''}),
										    ]					)






				@property
				def 			snake_case_    (  self					):

										"""simple docstring"""




										return 1e-4



