






import gc
import unittest

import numpy as np
import torch
import torch.nn.functional as F
from transformers import (
    ClapTextConfig,
    ClapTextModelWithProjection,
    RobertaTokenizer,
    SpeechTaHifiGan,
    SpeechTaHifiGanConfig,
)

from diffusers import (
    AudioLDMPipeline,
    AutoencoderKL,
    DDIMScheduler,
    LMSDiscreteScheduler,
    PNDMScheduler,
    UNetaDConditionModel,
)
from diffusers.utils import is_xformers_available, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism

from ..pipeline_params import TEXT_TO_AUDIO_BATCH_PARAMS, TEXT_TO_AUDIO_PARAMS
from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()
class    _UpperCAmelCase      ( A__	,unittest.TestCase			):

				"""simple docstring"""




				lowercase__       							= AudioLDMPipeline
				lowercase__       							= TEXT_TO_AUDIO_PARAMS
				lowercase__       							= TEXT_TO_AUDIO_BATCH_PARAMS
				lowercase__       							= frozenset(
				    [
				        """num_inference_steps""",
				        """num_waveforms_per_prompt""",
				        """generator""",
				        """latents""",
				        """output_type""",
				        """return_dict""",
				        """callback""",
				        """callback_steps""",
				    ]			)




				def        lowercase__     (  self		:					Optional[Any]						):

								'''simple docstring'''
								torch.manual_seed(0						)
								lowercase__     				=    UNetaDConditionModel(
								    block_out_channels=(32, 64),						layers_per_block=2,						sample_size=32,						in_channels=4,						out_channels=4,						down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D'''),						up_block_types=('''CrossAttnUpBlock2D''', '''UpBlock2D'''),						cross_attention_dim=(32, 64),						class_embed_type='''simple_projection''',						projection_class_embeddings_input_dim=32,						class_embeddings_concat=lowerCamelCase,						)
								lowercase__     				=    DDIMScheduler(
								    beta_start=0.00085,						beta_end=0.012,						beta_schedule='''scaled_linear''',						clip_sample=lowerCamelCase,						set_alpha_to_one=lowerCamelCase,						)
								torch.manual_seed(0						)
								lowercase__     				=    AutoencoderKL(
								    block_out_channels=[32, 64],						in_channels=1,						out_channels=1,						down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D'''],						up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D'''],						latent_channels=4,						)
								torch.manual_seed(0						)
								lowercase__     				=    ClapTextConfig(
								    bos_token_id=0,						eos_token_id=2,						hidden_size=32,						intermediate_size=37,						layer_norm_eps=1E-05,						num_attention_heads=4,						num_hidden_layers=5,						pad_token_id=1,						vocab_size=1_000,						projection_dim=32,						)
								lowercase__     				=    ClapTextModelWithProjection(lowerCamelCase						)
								lowercase__     				=    RobertaTokenizer.from_pretrained('''hf-internal-testing/tiny-random-roberta''',						model_max_length=77						)

								lowercase__     				=    SpeechTaHifiGanConfig(
								    model_in_dim=8,						sampling_rate=16_000,						upsample_initial_channel=16,						upsample_rates=[2, 2],						upsample_kernel_sizes=[4, 4],						resblock_kernel_sizes=[3, 7],						resblock_dilation_sizes=[[1, 3, 5], [1, 3, 5]],						normalize_before=lowerCamelCase,						)

								lowercase__     				=    SpeechTaHifiGan(lowerCamelCase						)

								lowercase__     				=    {
								    '''unet''': unet,
								    '''scheduler''': scheduler,
								    '''vae''': vae,
								    '''text_encoder''': text_encoder,
								    '''tokenizer''': tokenizer,
								    '''vocoder''': vocoder,
								}
								return components




				def        lowercase__     (  self		:					Optional[int],						lowerCamelCase		:					str,						lowerCamelCase		:					Optional[Any]=0						):

								'''simple docstring'''
								if str(lowerCamelCase						).startswith('''mps'''						):
												lowercase__     				=    torch.manual_seed(lowerCamelCase						)
								else:
												lowercase__     				=    torch.Generator(device=lowerCamelCase						).manual_seed(lowerCamelCase						)
								lowercase__     				=    {
								    '''prompt''': '''A hammer hitting a wooden surface''',
								    '''generator''': generator,
								    '''num_inference_steps''': 2,
								    '''guidance_scale''': 6.0,
								}
								return inputs




				def        lowercase__     (  self		:					int						):

								'''simple docstring'''
								lowercase__     				=    '''cpu'''  # ensure determinism for the device-dependent torch.Generator

								lowercase__     				=    self.get_dummy_components()
								lowercase__     				=    AudioLDMPipeline(**lowerCamelCase						)
								lowercase__     				=    audioldm_pipe.to(lowerCamelCase						)
								audioldm_pipe.set_progress_bar_config(disable=lowerCamelCase						)

								lowercase__     				=    self.get_dummy_inputs(lowerCamelCase						)
								lowercase__     				=    audioldm_pipe(**lowerCamelCase						)
								lowercase__     				=    output.audios[0]

								assert audio.ndim == 1
								assert len(lowerCamelCase						) == 256

								lowercase__     				=    audio[:10]
								lowercase__     				=    np.array(
								    [-0.0050, 0.0050, -0.0060, 0.0033, -0.0026, 0.0033, -0.0027, 0.0033, -0.0028, 0.0033]						)

								assert np.abs(audio_slice - expected_slice						).max() < 1E-2




				def        lowercase__     (  self		:					List[str]						):

								'''simple docstring'''
								lowercase__     				=    self.get_dummy_components()
								lowercase__     				=    AudioLDMPipeline(**lowerCamelCase						)
								lowercase__     				=    audioldm_pipe.to(lowerCamelCase						)
								lowercase__     				=    audioldm_pipe.to(lowerCamelCase						)
								audioldm_pipe.set_progress_bar_config(disable=lowerCamelCase						)

								lowercase__     				=    self.get_dummy_inputs(lowerCamelCase						)
								lowercase__     				=    3 * [inputs['''prompt''']]

								# forward
								lowercase__     				=    audioldm_pipe(**lowerCamelCase						)
								lowercase__     				=    output.audios[0]

								lowercase__     				=    self.get_dummy_inputs(lowerCamelCase						)
								lowercase__     				=    3 * [inputs.pop('''prompt'''						)]

								lowercase__     				=    audioldm_pipe.tokenizer(
								    lowerCamelCase,						padding='''max_length''',						max_length=audioldm_pipe.tokenizer.model_max_length,						truncation=lowerCamelCase,						return_tensors='''pt''',						)
								lowercase__     				=    text_inputs['''input_ids'''].to(lowerCamelCase						)

								lowercase__     				=    audioldm_pipe.text_encoder(
								    lowerCamelCase,						)
								lowercase__     				=    prompt_embeds.text_embeds
								# additional L_2 normalization over each hidden-state
								lowercase__     				=    F.normalize(lowerCamelCase,						dim=-1						)

								lowercase__     				=    prompt_embeds

								# forward
								lowercase__     				=    audioldm_pipe(**lowerCamelCase						)
								lowercase__     				=    output.audios[0]

								assert np.abs(audio_a - audio_a						).max() < 1E-2




				def        lowercase__     (  self		:					Dict						):

								'''simple docstring'''
								lowercase__     				=    self.get_dummy_components()
								lowercase__     				=    AudioLDMPipeline(**lowerCamelCase						)
								lowercase__     				=    audioldm_pipe.to(lowerCamelCase						)
								lowercase__     				=    audioldm_pipe.to(lowerCamelCase						)
								audioldm_pipe.set_progress_bar_config(disable=lowerCamelCase						)

								lowercase__     				=    self.get_dummy_inputs(lowerCamelCase						)
								lowercase__     				=    3 * ['''this is a negative prompt''']
								lowercase__     				=    negative_prompt
								lowercase__     				=    3 * [inputs['''prompt''']]

								# forward
								lowercase__     				=    audioldm_pipe(**lowerCamelCase						)
								lowercase__     				=    output.audios[0]

								lowercase__     				=    self.get_dummy_inputs(lowerCamelCase						)
								lowercase__     				=    3 * [inputs.pop('''prompt'''						)]

								lowercase__     				=    []
								for p in [prompt, negative_prompt]:
												lowercase__     				=    audioldm_pipe.tokenizer(
												    lowerCamelCase,						padding='''max_length''',						max_length=audioldm_pipe.tokenizer.model_max_length,						truncation=lowerCamelCase,						return_tensors='''pt''',						)
												lowercase__     				=    text_inputs['''input_ids'''].to(lowerCamelCase						)

												lowercase__     				=    audioldm_pipe.text_encoder(
												    lowerCamelCase,						)
												lowercase__     				=    text_embeds.text_embeds
												# additional L_2 normalization over each hidden-state
												lowercase__     				=    F.normalize(lowerCamelCase,						dim=-1						)

												embeds.append(lowerCamelCase						)

								lowercase__				,		lowercase__     				=    embeds

								# forward
								lowercase__     				=    audioldm_pipe(**lowerCamelCase						)
								lowercase__     				=    output.audios[0]

								assert np.abs(audio_a - audio_a						).max() < 1E-2




				def        lowercase__     (  self		:					Tuple						):

								'''simple docstring'''
								lowercase__     				=    '''cpu'''  # ensure determinism for the device-dependent torch.Generator
								lowercase__     				=    self.get_dummy_components()
								lowercase__     				=    PNDMScheduler(skip_prk_steps=lowerCamelCase						)
								lowercase__     				=    AudioLDMPipeline(**lowerCamelCase						)
								lowercase__     				=    audioldm_pipe.to(lowerCamelCase						)
								audioldm_pipe.set_progress_bar_config(disable=lowerCamelCase						)

								lowercase__     				=    self.get_dummy_inputs(lowerCamelCase						)
								lowercase__     				=    '''egg cracking'''
								lowercase__     				=    audioldm_pipe(**lowerCamelCase,						negative_prompt=lowerCamelCase						)
								lowercase__     				=    output.audios[0]

								assert audio.ndim == 1
								assert len(lowerCamelCase						) == 256

								lowercase__     				=    audio[:10]
								lowercase__     				=    np.array(
								    [-0.0051, 0.0050, -0.0060, 0.0034, -0.0026, 0.0033, -0.0027, 0.0033, -0.0028, 0.0032]						)

								assert np.abs(audio_slice - expected_slice						).max() < 1E-2




				def        lowercase__     (  self		:					Union[str, Any]						):

								'''simple docstring'''
								lowercase__     				=    '''cpu'''  # ensure determinism for the device-dependent torch.Generator
								lowercase__     				=    self.get_dummy_components()
								lowercase__     				=    PNDMScheduler(skip_prk_steps=lowerCamelCase						)
								lowercase__     				=    AudioLDMPipeline(**lowerCamelCase						)
								lowercase__     				=    audioldm_pipe.to(lowerCamelCase						)
								audioldm_pipe.set_progress_bar_config(disable=lowerCamelCase						)

								lowercase__     				=    '''A hammer hitting a wooden surface'''

								# test num_waveforms_per_prompt=1 (default)
								lowercase__     				=    audioldm_pipe(lowerCamelCase,						num_inference_steps=2						).audios

								assert audios.shape == (1, 256)

								# test num_waveforms_per_prompt=1 (default) for batch of prompts
								lowercase__     				=    2
								lowercase__     				=    audioldm_pipe([prompt] * batch_size,						num_inference_steps=2						).audios

								assert audios.shape == (batch_size, 256)

								# test num_waveforms_per_prompt for single prompt
								lowercase__     				=    2
								lowercase__     				=    audioldm_pipe(lowerCamelCase,						num_inference_steps=2,						num_waveforms_per_prompt=lowerCamelCase						).audios

								assert audios.shape == (num_waveforms_per_prompt, 256)

								# test num_waveforms_per_prompt for batch of prompts
								lowercase__     				=    2
								lowercase__     				=    audioldm_pipe(
								    [prompt] * batch_size,						num_inference_steps=2,						num_waveforms_per_prompt=lowerCamelCase						).audios

								assert audios.shape == (batch_size * num_waveforms_per_prompt, 256)




				def        lowercase__     (  self		:					Any						):

								'''simple docstring'''
								lowercase__     				=    '''cpu'''  # ensure determinism for the device-dependent torch.Generator
								lowercase__     				=    self.get_dummy_components()
								lowercase__     				=    AudioLDMPipeline(**lowerCamelCase						)
								lowercase__     				=    audioldm_pipe.to(lowerCamelCase						)
								audioldm_pipe.set_progress_bar_config(disable=lowerCamelCase						)
								lowercase__     				=    audioldm_pipe.vocoder.config.sampling_rate

								lowercase__     				=    self.get_dummy_inputs(lowerCamelCase						)
								lowercase__     				=    audioldm_pipe(audio_length_in_s=0.016,						**lowerCamelCase						)
								lowercase__     				=    output.audios[0]

								assert audio.ndim == 1
								assert len(lowerCamelCase						) / vocoder_sampling_rate == 0.016

								lowercase__     				=    audioldm_pipe(audio_length_in_s=0.032,						**lowerCamelCase						)
								lowercase__     				=    output.audios[0]

								assert audio.ndim == 1
								assert len(lowerCamelCase						) / vocoder_sampling_rate == 0.032




				def        lowercase__     (  self		:					str						):

								'''simple docstring'''
								lowercase__     				=    self.get_dummy_components()
								lowercase__     				=    AudioLDMPipeline(**lowerCamelCase						)
								lowercase__     				=    audioldm_pipe.to(lowerCamelCase						)
								audioldm_pipe.set_progress_bar_config(disable=lowerCamelCase						)

								lowercase__     				=    ['''hey''']

								lowercase__     				=    audioldm_pipe(lowerCamelCase,						num_inference_steps=1						)
								lowercase__     				=    output.audios.shape
								assert audio_shape == (1, 256)

								lowercase__     				=    audioldm_pipe.vocoder.config
								config.model_in_dim *= 2
								lowercase__     				=    SpeechTaHifiGan(lowerCamelCase						).to(lowerCamelCase						)
								lowercase__     				=    audioldm_pipe(lowerCamelCase,						num_inference_steps=1						)
								lowercase__     				=    output.audios.shape
								# waveform shape is unchanged, we just have 2x the number of mel channels in the spectrogram
								assert audio_shape == (1, 256)




				def        lowercase__     (  self		:					int						):

								'''simple docstring'''
								self._test_attention_slicing_forward_pass(test_mean_pixel_difference=lowerCamelCase						)




				def        lowercase__     (  self		:					Dict						):

								'''simple docstring'''
								self._test_inference_batch_single_identical(test_mean_pixel_difference=lowerCamelCase						)




				@unittest.skipIf(
				    torch_device != '''cuda''' or not is_xformers_available(),						reason='''XFormers attention is only available with CUDA and `xformers` installed''',						)
				def        lowercase__     (  self		:					Optional[Any]						):

								'''simple docstring'''
								self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=lowerCamelCase						)



@slow
class    _UpperCAmelCase      ( unittest.TestCase			):

				"""simple docstring"""




				def        lowercase__     (  self		:					int						):

								'''simple docstring'''
								super().tearDown()
								gc.collect()
								torch.cuda.empty_cache()




				def        lowercase__     (  self		:					Any,						lowerCamelCase		:					str,						lowerCamelCase		:					Optional[Any]="cpu",						lowerCamelCase		:					List[Any]=torch.floataa,						lowerCamelCase		:					List[str]=0						):

								'''simple docstring'''
								lowercase__     				=    torch.Generator(device=lowerCamelCase						).manual_seed(lowerCamelCase						)
								lowercase__     				=    np.random.RandomState(lowerCamelCase						).standard_normal((1, 8, 128, 16)						)
								lowercase__     				=    torch.from_numpy(lowerCamelCase						).to(device=lowerCamelCase,						dtype=lowerCamelCase						)
								lowercase__     				=    {
								    '''prompt''': '''A hammer hitting a wooden surface''',
								    '''latents''': latents,
								    '''generator''': generator,
								    '''num_inference_steps''': 3,
								    '''guidance_scale''': 2.5,
								}
								return inputs




				def        lowercase__     (  self		:					Tuple						):

								'''simple docstring'''
								lowercase__     				=    AudioLDMPipeline.from_pretrained('''cvssp/audioldm'''						)
								lowercase__     				=    audioldm_pipe.to(lowerCamelCase						)
								audioldm_pipe.set_progress_bar_config(disable=lowerCamelCase						)

								lowercase__     				=    self.get_inputs(lowerCamelCase						)
								lowercase__     				=    25
								lowercase__     				=    audioldm_pipe(**lowerCamelCase						).audios[0]

								assert audio.ndim == 1
								assert len(lowerCamelCase						) == 81_920

								lowercase__     				=    audio[77_230:77_240]
								lowercase__     				=    np.array(
								    [-0.4884, -0.4607, 0.0023, 0.5007, 0.5896, 0.5151, 0.3813, -0.0208, -0.3687, -0.4315]						)
								lowercase__     				=    np.abs(expected_slice - audio_slice						).max()
								assert max_diff < 1E-2




				def        lowercase__     (  self		:					int						):

								'''simple docstring'''
								lowercase__     				=    AudioLDMPipeline.from_pretrained('''cvssp/audioldm'''						)
								lowercase__     				=    LMSDiscreteScheduler.from_config(audioldm_pipe.scheduler.config						)
								lowercase__     				=    audioldm_pipe.to(lowerCamelCase						)
								audioldm_pipe.set_progress_bar_config(disable=lowerCamelCase						)

								lowercase__     				=    self.get_inputs(lowerCamelCase						)
								lowercase__     				=    audioldm_pipe(**lowerCamelCase						).audios[0]

								assert audio.ndim == 1
								assert len(lowerCamelCase						) == 81_920

								lowercase__     				=    audio[27_780:27_790]
								lowercase__     				=    np.array([-0.2131, -0.0873, -0.0124, -0.0189, 0.0569, 0.1373, 0.1883, 0.2886, 0.3297, 0.2212]						)
								lowercase__     				=    np.abs(expected_slice - audio_slice						).max()
								assert max_diff < 3E-2












from typing import TYPE_CHECKING

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


A__			:    Any         =				{'configuration_unispeech': ['UNISPEECH_PRETRAINED_CONFIG_ARCHIVE_MAP', 'UniSpeechConfig']}

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							A__			:    Union[str, Any]         =				[
							    'UNISPEECH_PRETRAINED_MODEL_ARCHIVE_LIST',
							    'UniSpeechForCTC',
							    'UniSpeechForPreTraining',
							    'UniSpeechForSequenceClassification',
							    'UniSpeechModel',
							    'UniSpeechPreTrainedModel',
							]

if TYPE_CHECKING:
							from .configuration_unispeech import UNISPEECH_PRETRAINED_CONFIG_ARCHIVE_MAP, UniSpeechConfig

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_unispeech import (
														    UNISPEECH_PRETRAINED_MODEL_ARCHIVE_LIST,
														    UniSpeechForCTC,
														    UniSpeechForPreTraining,
														    UniSpeechForSequenceClassification,
														    UniSpeechModel,
														    UniSpeechPreTrainedModel,
														)

else:
							import sys

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




