




import gc
import unittest

import numpy as np
import torch

from diffusers import StableDiffusionKDiffusionPipeline
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu


enable_full_determinism()




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






		def 					UpperCAmelCase			(     self      ):
								# clean up the VRAM after each test
								super().tearDown()
								gc.collect()
								torch.cuda.empty_cache()






		def 					UpperCAmelCase			(     self      ):
								_UpperCAmelCase	     =      StableDiffusionKDiffusionPipeline.from_pretrained("""CompVis/stable-diffusion-v1-4"""      )
								_UpperCAmelCase	     =      sd_pipe.to(__A      )
								sd_pipe.set_progress_bar_config(disable=__A      )

								sd_pipe.set_scheduler("""sample_euler"""      )

								_UpperCAmelCase	     =      """A painting of a squirrel eating a burger"""
								_UpperCAmelCase	     =      torch.manual_seed(0      )
								_UpperCAmelCase	     =      sd_pipe([prompt]    ,		generator=__A    ,		guidance_scale=9.0    ,		num_inference_steps=20    ,		output_type="""np"""      )

								_UpperCAmelCase	     =      output.images

								_UpperCAmelCase	     =      image[0, -3:, -3:, -1]

								assert image.shape == (1, 512, 512, 3)
								_UpperCAmelCase	     =      np.array([0.0447, 0.0492, 0.0468, 0.0408, 0.0383, 0.0408, 0.0354, 0.0380, 0.0339]      )

								assert np.abs(image_slice.flatten() - expected_slice      ).max() < 1e-2






		def 					UpperCAmelCase			(     self      ):
								_UpperCAmelCase	     =      StableDiffusionKDiffusionPipeline.from_pretrained("""stabilityai/stable-diffusion-2-1-base"""      )
								_UpperCAmelCase	     =      sd_pipe.to(__A      )
								sd_pipe.set_progress_bar_config(disable=__A      )

								sd_pipe.set_scheduler("""sample_euler"""      )

								_UpperCAmelCase	     =      """A painting of a squirrel eating a burger"""
								_UpperCAmelCase	     =      torch.manual_seed(0      )
								_UpperCAmelCase	     =      sd_pipe([prompt]    ,		generator=__A    ,		guidance_scale=9.0    ,		num_inference_steps=20    ,		output_type="""np"""      )

								_UpperCAmelCase	     =      output.images

								_UpperCAmelCase	     =      image[0, -3:, -3:, -1]

								assert image.shape == (1, 512, 512, 3)
								_UpperCAmelCase	     =      np.array([0.1237, 0.1320, 0.1438, 0.1359, 0.1390, 0.1132, 0.1277, 0.1175, 0.1112]      )

								assert np.abs(image_slice.flatten() - expected_slice      ).max() < 5e-1






		def 					UpperCAmelCase			(     self      ):
								_UpperCAmelCase	     =      StableDiffusionKDiffusionPipeline.from_pretrained("""stabilityai/stable-diffusion-2-1-base"""      )
								_UpperCAmelCase	     =      sd_pipe.to(__A      )
								sd_pipe.set_progress_bar_config(disable=__A      )

								sd_pipe.set_scheduler("""sample_dpmpp_2m"""      )

								_UpperCAmelCase	     =      """A painting of a squirrel eating a burger"""
								_UpperCAmelCase	     =      torch.manual_seed(0      )
								_UpperCAmelCase	     =      sd_pipe(
								    [prompt]    ,		generator=__A    ,		guidance_scale=7.5    ,		num_inference_steps=15    ,		output_type="""np"""    ,		use_karras_sigmas=__A    ,		)

								_UpperCAmelCase	     =      output.images

								_UpperCAmelCase	     =      image[0, -3:, -3:, -1]

								assert image.shape == (1, 512, 512, 3)
								_UpperCAmelCase	     =      np.array(
								    [0.1138_1689, 0.1211_2921, 0.138_9457, 0.1254_9606, 0.124_4964, 0.1083_1517, 0.1156_2866, 0.1086_7816, 0.1049_9048]      )

								assert np.abs(image_slice.flatten() - expected_slice      ).max() < 1e-2


from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_torch_available,
)


UpperCAmelCase_							:					Optional[Any]		 =   {
    '''configuration_wav2vec2''': ['''WAV_2_VEC_2_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''Wav2Vec2Config'''],
    '''feature_extraction_wav2vec2''': ['''Wav2Vec2FeatureExtractor'''],
    '''processing_wav2vec2''': ['''Wav2Vec2Processor'''],
    '''tokenization_wav2vec2''': ['''Wav2Vec2CTCTokenizer''', '''Wav2Vec2Tokenizer'''],
}


try:
			if not is_torch_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			UpperCAmelCase_							:					Optional[Any]		 =   [
			    '''WAV_2_VEC_2_PRETRAINED_MODEL_ARCHIVE_LIST''',
			    '''Wav2Vec2ForAudioFrameClassification''',
			    '''Wav2Vec2ForCTC''',
			    '''Wav2Vec2ForMaskedLM''',
			    '''Wav2Vec2ForPreTraining''',
			    '''Wav2Vec2ForSequenceClassification''',
			    '''Wav2Vec2ForXVector''',
			    '''Wav2Vec2Model''',
			    '''Wav2Vec2PreTrainedModel''',
			]

try:
			if not is_tf_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			UpperCAmelCase_							:					List[Any]		 =   [
			    '''TF_WAV_2_VEC_2_PRETRAINED_MODEL_ARCHIVE_LIST''',
			    '''TFWav2Vec2ForCTC''',
			    '''TFWav2Vec2Model''',
			    '''TFWav2Vec2PreTrainedModel''',
			    '''TFWav2Vec2ForSequenceClassification''',
			]

try:
			if not is_flax_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			UpperCAmelCase_							:					Dict		 =   [
			    '''FlaxWav2Vec2ForCTC''',
			    '''FlaxWav2Vec2ForPreTraining''',
			    '''FlaxWav2Vec2Model''',
			    '''FlaxWav2Vec2PreTrainedModel''',
			]


if TYPE_CHECKING:
			from .configuration_wavaveca import WAV_2_VEC_2_PRETRAINED_CONFIG_ARCHIVE_MAP, WavaVecaConfig
			from .feature_extraction_wavaveca import WavaVecaFeatureExtractor
			from .processing_wavaveca import WavaVecaProcessor
			from .tokenization_wavaveca import WavaVecaCTCTokenizer, WavaVecaTokenizer

			try:
						if not is_torch_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .modeling_wavaveca import (
						    WAV_2_VEC_2_PRETRAINED_MODEL_ARCHIVE_LIST,
						    WavaVecaForAudioFrameClassification,
						    WavaVecaForCTC,
						    WavaVecaForMaskedLM,
						    WavaVecaForPreTraining,
						    WavaVecaForSequenceClassification,
						    WavaVecaForXVector,
						    WavaVecaModel,
						    WavaVecaPreTrainedModel,
						)

			try:
						if not is_tf_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .modeling_tf_wavaveca import (
						    TF_WAV_2_VEC_2_PRETRAINED_MODEL_ARCHIVE_LIST,
						    TFWavaVecaForCTC,
						    TFWavaVecaForSequenceClassification,
						    TFWavaVecaModel,
						    TFWavaVecaPreTrainedModel,
						)

			try:
						if not is_flax_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .modeling_tf_wavaveca import (
						    FlaxWavaVecaForCTC,
						    FlaxWavaVecaForPreTraining,
						    FlaxWavaVecaModel,
						    FlaxWavaVecaPreTrainedModel,
						)


else:
			import sys

			UpperCAmelCase_							:					Optional[Any]		 =   _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)





