
from ..utils import (
    OptionalDependencyNotAvailable,
    is_flax_available,
    is_invisible_watermark_available,
    is_k_diffusion_available,
    is_librosa_available,
    is_note_seq_available,
    is_onnx_available,
    is_torch_available,
    is_transformers_available,
)


try:
				if not is_torch_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				from ..utils.dummy_pt_objects import *  # noqa F403
else:
				from .consistency_models import ConsistencyModelPipeline
				from .dance_diffusion import DanceDiffusionPipeline
				from .ddim import DDIMPipeline
				from .ddpm import DDPMPipeline
				from .dit import DiTPipeline
				from .latent_diffusion import LDMSuperResolutionPipeline
				from .latent_diffusion_uncond import LDMPipeline
				from .pipeline_utils import AudioPipelineOutput, DiffusionPipeline, ImagePipelineOutput
				from .pndm import PNDMPipeline
				from .repaint import RePaintPipeline
				from .score_sde_ve import ScoreSdeVePipeline
				from .stochastic_karras_ve import KarrasVePipeline

try:
				if not (is_torch_available() and is_librosa_available()):
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				from ..utils.dummy_torch_and_librosa_objects import *  # noqa F403
else:
				from .audio_diffusion import AudioDiffusionPipeline, Mel

try:
				if not (is_torch_available() and is_transformers_available()):
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				from ..utils.dummy_torch_and_transformers_objects import *  # noqa F403
else:
				from .alt_diffusion import AltDiffusionImgaImgPipeline, AltDiffusionPipeline
				from .audioldm import AudioLDMPipeline
				from .controlnet import (
				    StableDiffusionControlNetImgaImgPipeline,
				    StableDiffusionControlNetInpaintPipeline,
				    StableDiffusionControlNetPipeline,
				)
				from .deepfloyd_if import (
				    IFImgaImgPipeline,
				    IFImgaImgSuperResolutionPipeline,
				    IFInpaintingPipeline,
				    IFInpaintingSuperResolutionPipeline,
				    IFPipeline,
				    IFSuperResolutionPipeline,
				)
				from .kandinsky import (
				    KandinskyImgaImgPipeline,
				    KandinskyInpaintPipeline,
				    KandinskyPipeline,
				    KandinskyPriorPipeline,
				)
				from .kandinskya_a import (
				    KandinskyVaaControlnetImgaImgPipeline,
				    KandinskyVaaControlnetPipeline,
				    KandinskyVaaImgaImgPipeline,
				    KandinskyVaaInpaintPipeline,
				    KandinskyVaaPipeline,
				    KandinskyVaaPriorEmbaEmbPipeline,
				    KandinskyVaaPriorPipeline,
				)
				from .latent_diffusion import LDMTextToImagePipeline
				from .paint_by_example import PaintByExamplePipeline
				from .semantic_stable_diffusion import SemanticStableDiffusionPipeline
				from .shap_e import ShapEImgaImgPipeline, ShapEPipeline
				from .stable_diffusion import (
				    CycleDiffusionPipeline,
				    StableDiffusionAttendAndExcitePipeline,
				    StableDiffusionDepthaImgPipeline,
				    StableDiffusionDiffEditPipeline,
				    StableDiffusionImageVariationPipeline,
				    StableDiffusionImgaImgPipeline,
				    StableDiffusionInpaintPipeline,
				    StableDiffusionInpaintPipelineLegacy,
				    StableDiffusionInstructPixaPixPipeline,
				    StableDiffusionLatentUpscalePipeline,
				    StableDiffusionLDMaDPipeline,
				    StableDiffusionModelEditingPipeline,
				    StableDiffusionPanoramaPipeline,
				    StableDiffusionParadigmsPipeline,
				    StableDiffusionPipeline,
				    StableDiffusionPixaPixZeroPipeline,
				    StableDiffusionSAGPipeline,
				    StableDiffusionUpscalePipeline,
				    StableUnCLIPImgaImgPipeline,
				    StableUnCLIPPipeline,
				)
				from .stable_diffusion_safe import StableDiffusionPipelineSafe
				from .text_to_video_synthesis import TextToVideoSDPipeline, TextToVideoZeroPipeline, VideoToVideoSDPipeline
				from .unclip import UnCLIPImageVariationPipeline, UnCLIPPipeline
				from .unidiffuser import ImageTextPipelineOutput, UniDiffuserModel, UniDiffuserPipeline, UniDiffuserTextDecoder
				from .versatile_diffusion import (
				    VersatileDiffusionDualGuidedPipeline,
				    VersatileDiffusionImageVariationPipeline,
				    VersatileDiffusionPipeline,
				    VersatileDiffusionTextToImagePipeline,
				)
				from .vq_diffusion import VQDiffusionPipeline


try:
				if not (is_torch_available() and is_transformers_available() and is_invisible_watermark_available()):
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				from ..utils.dummy_torch_and_transformers_and_invisible_watermark_objects import *  # noqa F403
else:
				from .stable_diffusion_xl import StableDiffusionXLImgaImgPipeline, StableDiffusionXLPipeline

try:
				if not is_onnx_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				from ..utils.dummy_onnx_objects import *  # noqa F403
else:
				from .onnx_utils import OnnxRuntimeModel

try:
				if not (is_torch_available() and is_transformers_available() and is_onnx_available()):
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				from ..utils.dummy_torch_and_transformers_and_onnx_objects import *  # noqa F403
else:
				from .stable_diffusion import (
				    OnnxStableDiffusionImgaImgPipeline,
				    OnnxStableDiffusionInpaintPipeline,
				    OnnxStableDiffusionInpaintPipelineLegacy,
				    OnnxStableDiffusionPipeline,
				    OnnxStableDiffusionUpscalePipeline,
				    StableDiffusionOnnxPipeline,
				)

try:
				if not (is_torch_available() and is_transformers_available() and is_k_diffusion_available()):
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				from ..utils.dummy_torch_and_transformers_and_k_diffusion_objects import *  # noqa F403
else:
				from .stable_diffusion import StableDiffusionKDiffusionPipeline

try:
				if not is_flax_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				from ..utils.dummy_flax_objects import *  # noqa F403
else:
				from .pipeline_flax_utils import FlaxDiffusionPipeline


try:
				if not (is_flax_available() and is_transformers_available()):
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				from ..utils.dummy_flax_and_transformers_objects import *  # noqa F403
else:
				from .controlnet import FlaxStableDiffusionControlNetPipeline
				from .stable_diffusion import (
				    FlaxStableDiffusionImgaImgPipeline,
				    FlaxStableDiffusionInpaintPipeline,
				    FlaxStableDiffusionPipeline,
				)
try:
				if not (is_transformers_available() and is_torch_available() and is_note_seq_available()):
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				from ..utils.dummy_transformers_and_torch_and_note_seq_objects import *  # noqa F403
else:
				from .spectrogram_diffusion import MidiProcessor, SpectrogramDiffusionPipeline






from typing import Dict, List, Optional, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import center_crop, normalize, rescale, resize, to_channel_dimension_format
from ...image_utils import (
    IMAGENET_STANDARD_MEAN,
    IMAGENET_STANDARD_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_vision_available, logging


if is_vision_available():
				import PIL


__lowerCamelCase								=					logging.get_logger(__name__)
class    _UpperCamelCase(   SCREAMING_SNAKE_CASE				):
						__A:						Union[str, Any]				   =      ["""pixel_values"""]

						def __init__(					self		:			str	,						_lowerCamelCase		:			bool = True	,						_lowerCamelCase		:			Dict[str, int] = None	,						_lowerCamelCase		:			PILImageResampling = PIL.Image.NEAREST	,						_lowerCamelCase		:			bool = False	,						_lowerCamelCase		:			Dict[str, int] = None	,						_lowerCamelCase		:			Union[int, float] = 1 / 2_55	,						_lowerCamelCase		:			bool = False	,						_lowerCamelCase		:			bool = True	,						_lowerCamelCase		:			bool = True	,						_lowerCamelCase		:			Optional[Union[float, List[float]]] = None	,						_lowerCamelCase		:			Optional[Union[float, List[float]]] = None	,						_lowerCamelCase		:			bool = True	,						**_lowerCamelCase		:			Tuple	,						):
													super().__init__(**_lowerCamelCase			)
													_UpperCAmelCase  :			int	       =		size if size is not None else {"height": 3_46, "width": 3_46}
													_UpperCAmelCase  :			Dict	       =		get_size_dict(_lowerCamelCase			)
													_UpperCAmelCase  :			List[str]	       =		crop_size if crop_size is not None else {"height": 2_89, "width": 2_89}
													_UpperCAmelCase  :			int	       =		get_size_dict(_lowerCamelCase	,						param_name="crop_size"			)

													_UpperCAmelCase  :			Dict	       =		do_resize
													_UpperCAmelCase  :			Tuple	       =		size
													_UpperCAmelCase  :			Union[str, Any]	       =		resample
													_UpperCAmelCase  :			List[Any]	       =		do_center_crop
													_UpperCAmelCase  :			List[str]	       =		crop_size
													_UpperCAmelCase  :			int	       =		do_rescale
													_UpperCAmelCase  :			str	       =		rescale_factor
													_UpperCAmelCase  :			int	       =		rescale_offset
													_UpperCAmelCase  :			Any	       =		do_normalize
													_UpperCAmelCase  :			Optional[int]	       =		image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
													_UpperCAmelCase  :			List[str]	       =		image_std if image_std is not None else IMAGENET_STANDARD_STD
													_UpperCAmelCase  :			Dict	       =		include_top

						def 						a__ (					self		:			Optional[Any]	,						_lowerCamelCase		:			np.ndarray	,						_lowerCamelCase		:			Dict[str, int]	,						_lowerCamelCase		:			PILImageResampling = PIL.Image.NEAREST	,						_lowerCamelCase		:			Optional[Union[str, ChannelDimension]] = None	,						**_lowerCamelCase		:			Tuple	,						):
													_UpperCAmelCase  :			Optional[int]	       =		get_size_dict(_lowerCamelCase			)
													if "height" not in size or "width" not in size:
																				raise ValueError(f"""The size dictionary must have keys 'height' and 'width'. Got {size.keys()}"""			)
													return resize(
													    _lowerCamelCase	,						size=(size["height"], size["width"])	,						resample=_lowerCamelCase	,						data_format=_lowerCamelCase	,						**_lowerCamelCase			)

						def 						a__ (					self		:			Optional[Any]	,						_lowerCamelCase		:			np.ndarray	,						_lowerCamelCase		:			Dict[str, int]	,						_lowerCamelCase		:			Optional[Union[str, ChannelDimension]] = None	,						**_lowerCamelCase		:			List[str]	,						):
													_UpperCAmelCase  :			Optional[Any]	       =		get_size_dict(_lowerCamelCase			)
													if "height" not in size or "width" not in size:
																				raise ValueError(f"""The size dictionary must have keys 'height' and 'width'. Got {size.keys()}"""			)
													return center_crop(_lowerCamelCase	,						size=(size["height"], size["width"])	,						data_format=_lowerCamelCase	,						**_lowerCamelCase			)

						def 						a__ (					self		:			Optional[Any]	,						_lowerCamelCase		:			np.ndarray	,						_lowerCamelCase		:			Union[int, float]	,						_lowerCamelCase		:			bool = True	,						_lowerCamelCase		:			Optional[Union[str, ChannelDimension]] = None	,						**_lowerCamelCase		:			Tuple	,						):
													if offset:
																				_UpperCAmelCase  :			Any	       =		(image - 1_27.5) * scale
																				if data_format is not None:
																											_UpperCAmelCase  :			Union[str, Any]	       =		to_channel_dimension_format(_lowerCamelCase	,						_lowerCamelCase			)
																				_UpperCAmelCase  :			Optional[Any]	       =		rescaled_image.astype(np.floataa			)
													else:
																				_UpperCAmelCase  :			List[Any]	       =		rescale(_lowerCamelCase	,						scale=_lowerCamelCase	,						data_format=_lowerCamelCase	,						**_lowerCamelCase			)
													return rescaled_image

						def 						a__ (					self		:			Union[str, Any]	,						_lowerCamelCase		:			np.ndarray	,						_lowerCamelCase		:			Union[float, List[float]]	,						_lowerCamelCase		:			Union[float, List[float]]	,						_lowerCamelCase		:			Optional[Union[str, ChannelDimension]] = None	,						**_lowerCamelCase		:			Union[str, Any]	,						):
													return normalize(_lowerCamelCase	,						mean=_lowerCamelCase	,						std=_lowerCamelCase	,						data_format=_lowerCamelCase	,						**_lowerCamelCase			)






						def 						a__ (					self		:			str	,						_lowerCamelCase		:			ImageInput	,						_lowerCamelCase		:			bool = None	,						_lowerCamelCase		:			Dict[str, int] = None	,						_lowerCamelCase		:			List[Any]=None	,						_lowerCamelCase		:			bool = None	,						_lowerCamelCase		:			Dict[str, int] = None	,						_lowerCamelCase		:			bool = None	,						_lowerCamelCase		:			float = None	,						_lowerCamelCase		:			bool = None	,						_lowerCamelCase		:			bool = None	,						_lowerCamelCase		:			Optional[Union[float, List[float]]] = None	,						_lowerCamelCase		:			Optional[Union[float, List[float]]] = None	,						_lowerCamelCase		:			bool = None	,						_lowerCamelCase		:			Optional[Union[str, TensorType]] = None	,						_lowerCamelCase		:			ChannelDimension = ChannelDimension.FIRST	,						**_lowerCamelCase		:			str	,						):
													_UpperCAmelCase  :			Optional[Any]	       =		do_resize if do_resize is not None else self.do_resize
													_UpperCAmelCase  :			Optional[int]	       =		resample if resample is not None else self.resample
													_UpperCAmelCase  :			Tuple	       =		do_center_crop if do_center_crop is not None else self.do_center_crop
													_UpperCAmelCase  :			str	       =		do_rescale if do_rescale is not None else self.do_rescale
													_UpperCAmelCase  :			str	       =		rescale_factor if rescale_factor is not None else self.rescale_factor
													_UpperCAmelCase  :			Tuple	       =		rescale_offset if rescale_offset is not None else self.rescale_offset
													_UpperCAmelCase  :			str	       =		do_normalize if do_normalize is not None else self.do_normalize
													_UpperCAmelCase  :			Dict	       =		image_mean if image_mean is not None else self.image_mean
													_UpperCAmelCase  :			Tuple	       =		image_std if image_std is not None else self.image_std
													_UpperCAmelCase  :			Tuple	       =		include_top if include_top is not None else self.include_top

													_UpperCAmelCase  :			Optional[int]	       =		size if size is not None else self.size
													_UpperCAmelCase  :			Union[str, Any]	       =		get_size_dict(_lowerCamelCase			)
													_UpperCAmelCase  :			int	       =		crop_size if crop_size is not None else self.crop_size
													_UpperCAmelCase  :			int	       =		get_size_dict(_lowerCamelCase	,						param_name="crop_size"			)

													_UpperCAmelCase  :			Union[str, Any]	       =		make_list_of_images(_lowerCamelCase			)

													if not valid_images(_lowerCamelCase			):
																				raise ValueError(
																				    "Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, "
																				    "torch.Tensor, tf.Tensor or jax.ndarray."			)

													if do_resize and size is None or resample is None:
																				raise ValueError("Size and resample must be specified if do_resize is True."			)

													if do_center_crop and crop_size is None:
																				raise ValueError("Crop size must be specified if do_center_crop is True."			)

													if do_rescale and rescale_factor is None:
																				raise ValueError("Rescale factor must be specified if do_rescale is True."			)

													if do_normalize and (image_mean is None or image_std is None):
																				raise ValueError("Image mean and std must be specified if do_normalize is True."			)

													# All transformations expect numpy arrays.
													_UpperCAmelCase  :			Dict	       =		[to_numpy_array(_lowerCamelCase			) for image in images]

													if do_resize:
																				_UpperCAmelCase  :			Any	       =		[self.resize(image=_lowerCamelCase	,						size=_lowerCamelCase	,						resample=_lowerCamelCase			) for image in images]

													if do_center_crop:
																				_UpperCAmelCase  :			int	       =		[self.center_crop(image=_lowerCamelCase	,						size=_lowerCamelCase			) for image in images]

													if do_rescale:
																				_UpperCAmelCase  :			int	       =		[self.rescale(image=_lowerCamelCase	,						scale=_lowerCamelCase	,						offset=_lowerCamelCase			) for image in images]

													if do_normalize:
																				_UpperCAmelCase  :			str	       =		[self.normalize(image=_lowerCamelCase	,						mean=_lowerCamelCase	,						std=_lowerCamelCase			) for image in images]

													if include_top:
																				_UpperCAmelCase  :			int	       =		[self.normalize(image=_lowerCamelCase	,						mean=[0, 0, 0]	,						std=_lowerCamelCase			) for image in images]

													_UpperCAmelCase  :			str	       =		[to_channel_dimension_format(_lowerCamelCase	,						_lowerCamelCase			) for image in images]

													_UpperCAmelCase  :			Dict	       =		{"pixel_values": images}
													return BatchFeature(data=_lowerCamelCase	,						tensor_type=_lowerCamelCase			)




