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









import copy
import inspect

from transformers.testing_utils import require_torch, torch_device
from transformers.utils.backbone_utils import BackboneType







@require_torch
class      __lowercase  :





							"""simple docstring"""







							_UpperCAmelCase     =		()
							_UpperCAmelCase     =		True






							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_						:			Union[str, Any]       						= self.config_class

										# test default config
										SCREAMING_SNAKE_CASE_						:			Tuple       						= config_class()
										self.assertIsNotNone(lowerCAmelCase__    )
										SCREAMING_SNAKE_CASE_						:			Dict       						= ['stem'] + [F'''stage{idx}''' for idx in range(1       ,		len(config.depths    ) + 1    )]
										self.assertEqual(config.stage_names       ,		lowerCAmelCase__    )
										self.assertTrue(set(config.out_features    ).issubset(set(config.stage_names    )    )    )

										# Test out_features and out_indices are correctly set
										# out_features and out_indices both None
										SCREAMING_SNAKE_CASE_						:			List[Any]       						= config_class(out_features=lowerCAmelCase__       ,		out_indices=lowerCAmelCase__    )
										self.assertEqual(config.out_features       ,		[config.stage_names[-1]]    )
										self.assertEqual(config.out_indices       ,		[len(config.stage_names    ) - 1]    )

										# out_features and out_indices both set
										SCREAMING_SNAKE_CASE_						:			str       						= config_class(out_features=['stem', 'stage1']       ,		out_indices=[0, 1]    )
										self.assertEqual(config.out_features       ,		['stem', 'stage1']    )
										self.assertEqual(config.out_indices       ,		[0, 1]    )

										# Only out_features set
										SCREAMING_SNAKE_CASE_						:			List[str]       						= config_class(out_features=['stage1', 'stage3']    )
										self.assertEqual(config.out_features       ,		['stage1', 'stage3']    )
										self.assertEqual(config.out_indices       ,		[1, 3]    )

										# Only out_indices set
										SCREAMING_SNAKE_CASE_						:			List[Any]       						= config_class(out_indices=[0, 2]    )
										self.assertEqual(config.out_features       ,		[config.stage_names[0], config.stage_names[2]]    )
										self.assertEqual(config.out_indices       ,		[0, 2]    )

										# Error raised when out_indices do not correspond to out_features
										with self.assertRaises(lowerCAmelCase__    ):
													SCREAMING_SNAKE_CASE_						:			str       						= config_class(out_features=['stage1', 'stage2']       ,		out_indices=[0, 2]    )






							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_						,	SCREAMING_SNAKE_CASE_						:			Tuple       						= self.model_tester.prepare_config_and_inputs_for_common()

										for model_class in self.all_model_classes:
													SCREAMING_SNAKE_CASE_						:			Union[str, Any]       						= model_class(lowerCAmelCase__    )
													SCREAMING_SNAKE_CASE_						:			int       						= inspect.signature(model.forward    )
													# signature.parameters is an OrderedDict => so arg_names order is deterministic
													SCREAMING_SNAKE_CASE_						:			Any       						= [*signature.parameters.keys()]
													SCREAMING_SNAKE_CASE_						:			Optional[int]       						= ['pixel_values']
													self.assertListEqual(arg_names[:1]       ,		lowerCAmelCase__    )






							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_						,	SCREAMING_SNAKE_CASE_						:			str       						= self.model_tester.prepare_config_and_inputs_for_common()

										for model_class in self.all_model_classes:
													SCREAMING_SNAKE_CASE_						:			Any       						= model_class(lowerCAmelCase__    )
													self.assertEqual(len(model.channels    )       ,		len(config.out_features    )    )
													SCREAMING_SNAKE_CASE_						:			Union[str, Any]       						= model.num_features
													SCREAMING_SNAKE_CASE_						:			Dict       						= [config.stage_names.index(lowerCAmelCase__    ) for feat in config.out_features]
													SCREAMING_SNAKE_CASE_						:			List[str]       						= [num_features[idx] for idx in out_indices]
													self.assertListEqual(model.channels       ,		lowerCAmelCase__    )

													SCREAMING_SNAKE_CASE_						:			Tuple       						= copy.deepcopy(lowerCAmelCase__    )
													SCREAMING_SNAKE_CASE_						:			Dict       						= None
													SCREAMING_SNAKE_CASE_						:			Optional[Any]       						= model_class(lowerCAmelCase__    )
													self.assertEqual(len(model.channels    )       ,		1    )
													self.assertListEqual(model.channels       ,		[num_features[-1]]    )

													SCREAMING_SNAKE_CASE_						:			Dict       						= copy.deepcopy(lowerCAmelCase__    )
													SCREAMING_SNAKE_CASE_						:			Tuple       						= None
													SCREAMING_SNAKE_CASE_						:			int       						= model_class(lowerCAmelCase__    )
													self.assertEqual(len(model.channels    )       ,		1    )
													self.assertListEqual(model.channels       ,		[num_features[-1]]    )






							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_						,	SCREAMING_SNAKE_CASE_						:			Optional[Any]       						= self.model_tester.prepare_config_and_inputs_for_common()

										for model_class in self.all_model_classes:
													SCREAMING_SNAKE_CASE_						:			Optional[Any]       						= model_class(lowerCAmelCase__    )
													model.to(lowerCAmelCase__    )
													model.eval()
													SCREAMING_SNAKE_CASE_						:			Optional[Any]       						= model(**lowerCAmelCase__    )

													self.assertEqual(len(result.feature_maps    )       ,		len(config.out_features    )    )
													self.assertEqual(len(model.channels    )       ,		len(config.out_features    )    )
													self.assertEqual(len(result.feature_maps    )       ,		len(config.out_indices    )    )
													self.assertEqual(len(model.channels    )       ,		len(config.out_indices    )    )

													# Check output of last stage is taken if out_features=None, out_indices=None
													SCREAMING_SNAKE_CASE_						:			Union[str, Any]       						= copy.deepcopy(lowerCAmelCase__    )
													SCREAMING_SNAKE_CASE_						:			Union[str, Any]       						= None
													SCREAMING_SNAKE_CASE_						:			int       						= model_class(lowerCAmelCase__    )
													model.to(lowerCAmelCase__    )
													model.eval()
													SCREAMING_SNAKE_CASE_						:			List[Any]       						= model(**lowerCAmelCase__    )

													self.assertEqual(len(result.feature_maps    )       ,		1    )
													self.assertEqual(len(model.channels    )       ,		1    )

													SCREAMING_SNAKE_CASE_						:			Tuple       						= copy.deepcopy(lowerCAmelCase__    )
													SCREAMING_SNAKE_CASE_						:			int       						= None
													SCREAMING_SNAKE_CASE_						:			Dict       						= model_class(lowerCAmelCase__    )
													model.to(lowerCAmelCase__    )
													model.eval()
													SCREAMING_SNAKE_CASE_						:			List[str]       						= model(**lowerCAmelCase__    )

													self.assertEqual(len(result.feature_maps    )       ,		1    )
													self.assertEqual(len(model.channels    )       ,		1    )

													# Check backbone can be initialized with fresh weights
													SCREAMING_SNAKE_CASE_						:			Tuple       						= copy.deepcopy(lowerCAmelCase__    )
													SCREAMING_SNAKE_CASE_						:			Dict       						= False
													SCREAMING_SNAKE_CASE_						:			Optional[Any]       						= model_class(lowerCAmelCase__    )
													model.to(lowerCAmelCase__    )
													model.eval()
													SCREAMING_SNAKE_CASE_						:			str       						= model(**lowerCAmelCase__    )






							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_						,	SCREAMING_SNAKE_CASE_						:			Optional[Any]       						= self.model_tester.prepare_config_and_inputs_for_common()

										for backbone_class in self.all_model_classes:
													SCREAMING_SNAKE_CASE_						:			List[str]       						= backbone_class(lowerCAmelCase__    )

													self.assertTrue(hasattr(lowerCAmelCase__       ,		'backbone_type'    )    )
													self.assertTrue(hasattr(lowerCAmelCase__       ,		'stage_names'    )    )
													self.assertTrue(hasattr(lowerCAmelCase__       ,		'num_features'    )    )
													self.assertTrue(hasattr(lowerCAmelCase__       ,		'out_indices'    )    )
													self.assertTrue(hasattr(lowerCAmelCase__       ,		'out_features'    )    )
													self.assertTrue(hasattr(lowerCAmelCase__       ,		'out_feature_channels'    )    )
													self.assertTrue(hasattr(lowerCAmelCase__       ,		'channels'    )    )

													self.assertIsInstance(backbone.backbone_type       ,		lowerCAmelCase__    )
													# Verify num_features has been initialized in the backbone init
													self.assertIsNotNone(backbone.num_features    )
													self.assertTrue(len(backbone.channels    ) == len(backbone.out_indices    )    )
													self.assertTrue(len(backbone.stage_names    ) == len(backbone.num_features    )    )
													self.assertTrue(len(backbone.channels    ) <= len(backbone.num_features    )    )
													self.assertTrue(len(backbone.out_feature_channels    ) == len(backbone.stage_names    )    )






							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_						,	SCREAMING_SNAKE_CASE_						:			List[str]       						= self.model_tester.prepare_config_and_inputs_for_common()
										SCREAMING_SNAKE_CASE_						:			Tuple       						= inputs_dict['pixel_values'].shape[0]

										for backbone_class in self.all_model_classes:
													SCREAMING_SNAKE_CASE_						:			Optional[int]       						= backbone_class(lowerCAmelCase__    )
													backbone.to(lowerCAmelCase__    )
													backbone.eval()

													SCREAMING_SNAKE_CASE_						:			Dict       						= backbone(**lowerCAmelCase__    )

													# Test default outputs and verify feature maps
													self.assertIsInstance(outputs.feature_maps       ,		lowerCAmelCase__    )
													self.assertTrue(len(outputs.feature_maps    ) == len(backbone.channels    )    )
													for feature_map, n_channels in zip(outputs.feature_maps       ,		backbone.channels    ):
																self.assertTrue(feature_map.shape[:2]       ,		(batch_size, n_channels)    )
													self.assertIsNone(outputs.hidden_states    )
													self.assertIsNone(outputs.attentions    )

													# Test output_hidden_states=True
													SCREAMING_SNAKE_CASE_						:			List[Any]       						= backbone(**lowerCAmelCase__       ,		output_hidden_states=lowerCAmelCase__    )
													self.assertIsNotNone(outputs.hidden_states    )
													self.assertTrue(len(outputs.hidden_states    )       ,		len(backbone.stage_names    )    )
													for hidden_state, n_channels in zip(outputs.hidden_states       ,		backbone.channels    ):
																self.assertTrue(hidden_state.shape[:2]       ,		(batch_size, n_channels)    )

													# Test output_attentions=True
													if self.has_attentions:
																SCREAMING_SNAKE_CASE_						:			Tuple       						= backbone(**lowerCAmelCase__       ,		output_attentions=lowerCAmelCase__    )
																self.assertIsNotNone(outputs.attentions    )





