




'''simple docstring'''







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     _a						(			__a							,							unittest.TestCase				):
       __a       :  List[str]            =      AudioLDMPipeline
       __a       :  List[Any]            =      TEXT_TO_AUDIO_PARAMS
       __a       :  Optional[int]            =      TEXT_TO_AUDIO_BATCH_PARAMS
       __a       :  List[Any]            =      frozenset(
           [
               """num_inference_steps""",
               """num_waveforms_per_prompt""",
               """generator""",
               """latents""",
               """output_type""",
               """return_dict""",
               """callback""",
               """callback_steps""",
           ]				)
       def 					A   (			self		:			Any       ):



           '''simple docstring'''

           torch.manual_seed(0       )
           UpperCAmelCase     =	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=lowercase     ,       )
           UpperCAmelCase     =	DDIMScheduler(
               beta_start=0.0_0085     ,       beta_end=0.012     ,       beta_schedule='''scaled_linear'''     ,       clip_sample=lowercase     ,       set_alpha_to_one=lowercase     ,       )
           torch.manual_seed(0       )
           UpperCAmelCase     =	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       )
           UpperCAmelCase     =	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     ,       )
           UpperCAmelCase     =	ClapTextModelWithProjection(lowercase       )
           UpperCAmelCase     =	RobertaTokenizer.from_pretrained('''hf-internal-testing/tiny-random-roberta'''     ,       model_max_length=77       )

           UpperCAmelCase     =	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=lowercase     ,       )

           UpperCAmelCase     =	SpeechTaHifiGan(lowercase       )

           UpperCAmelCase     =	{
               '''unet''': unet,
               '''scheduler''': scheduler,
               '''vae''': vae,
               '''text_encoder''': text_encoder,
               '''tokenizer''': tokenizer,
               '''vocoder''': vocoder,
           }
           return components
       def 					A   (			self		:			List[Any]     ,       lowercase		:			Tuple     ,       lowercase		:			Optional[Any]=0       ):



           '''simple docstring'''

           if str(lowercase       ).startswith('''mps'''       ):
               UpperCAmelCase     =	torch.manual_seed(lowercase       )
           else:
               UpperCAmelCase     =	torch.Generator(device=lowercase       ).manual_seed(lowercase       )
           UpperCAmelCase     =	{
               '''prompt''': '''A hammer hitting a wooden surface''',
               '''generator''': generator,
               '''num_inference_steps''': 2,
               '''guidance_scale''': 6.0,
           }
           return inputs
       def 					A   (			self		:			Optional[Any]       ):



           '''simple docstring'''

           UpperCAmelCase     =	'''cpu'''  # ensure determinism for the device-dependent torch.Generator

           UpperCAmelCase     =	self.get_dummy_components()
           UpperCAmelCase     =	AudioLDMPipeline(**lowercase       )
           UpperCAmelCase     =	audioldm_pipe.to(lowercase       )
           audioldm_pipe.set_progress_bar_config(disable=lowercase       )

           UpperCAmelCase     =	self.get_dummy_inputs(lowercase       )
           UpperCAmelCase     =	audioldm_pipe(**lowercase       )
           UpperCAmelCase     =	output.audios[0]

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

           UpperCAmelCase     =	audio[:10]
           UpperCAmelCase     =	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 					A   (			self		:			Optional[Any]       ):



           '''simple docstring'''

           UpperCAmelCase     =	self.get_dummy_components()
           UpperCAmelCase     =	AudioLDMPipeline(**lowercase       )
           UpperCAmelCase     =	audioldm_pipe.to(lowercase       )
           UpperCAmelCase     =	audioldm_pipe.to(lowercase       )
           audioldm_pipe.set_progress_bar_config(disable=lowercase       )

           UpperCAmelCase     =	self.get_dummy_inputs(lowercase       )
           UpperCAmelCase     =	3 * [inputs['''prompt''']]

           # forward
           UpperCAmelCase     =	audioldm_pipe(**lowercase       )
           UpperCAmelCase     =	output.audios[0]

           UpperCAmelCase     =	self.get_dummy_inputs(lowercase       )
           UpperCAmelCase     =	3 * [inputs.pop('''prompt'''       )]

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

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

           UpperCAmelCase     =	prompt_embeds

           # forward
           UpperCAmelCase     =	audioldm_pipe(**lowercase       )
           UpperCAmelCase     =	output.audios[0]

           assert np.abs(audio_a - audio_a       ).max() < 1E-2
       def 					A   (			self		:			Optional[Any]       ):



           '''simple docstring'''

           UpperCAmelCase     =	self.get_dummy_components()
           UpperCAmelCase     =	AudioLDMPipeline(**lowercase       )
           UpperCAmelCase     =	audioldm_pipe.to(lowercase       )
           UpperCAmelCase     =	audioldm_pipe.to(lowercase       )
           audioldm_pipe.set_progress_bar_config(disable=lowercase       )

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

           # forward
           UpperCAmelCase     =	audioldm_pipe(**lowercase       )
           UpperCAmelCase     =	output.audios[0]

           UpperCAmelCase     =	self.get_dummy_inputs(lowercase       )
           UpperCAmelCase     =	3 * [inputs.pop('''prompt'''       )]

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

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

               embeds.append(lowercase       )

           UpperCAmelCase ,  UpperCAmelCase     =	embeds

           # forward
           UpperCAmelCase     =	audioldm_pipe(**lowercase       )
           UpperCAmelCase     =	output.audios[0]

           assert np.abs(audio_a - audio_a       ).max() < 1E-2
       def 					A   (			self		:			List[str]       ):



           '''simple docstring'''

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

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

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

           UpperCAmelCase     =	audio[:10]
           UpperCAmelCase     =	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 					A   (			self		:			Dict       ):



           '''simple docstring'''

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

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

           # test num_waveforms_per_prompt=1 (default)
           UpperCAmelCase     =	audioldm_pipe(lowercase     ,       num_inference_steps=2       ).audios

           assert audios.shape == (1, 256)

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

           assert audios.shape == (batch_size, 256)

           # test num_waveforms_per_prompt for single prompt
           UpperCAmelCase     =	2
           UpperCAmelCase     =	audioldm_pipe(lowercase     ,       num_inference_steps=2     ,       num_waveforms_per_prompt=lowercase       ).audios

           assert audios.shape == (num_waveforms_per_prompt, 256)

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

           assert audios.shape == (batch_size * num_waveforms_per_prompt, 256)
       def 					A   (			self		:			Union[str, Any]       ):



           '''simple docstring'''

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

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

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

           UpperCAmelCase     =	audioldm_pipe(audio_length_in_s=0.032     ,       **lowercase       )
           UpperCAmelCase     =	output.audios[0]

           assert audio.ndim == 1
           assert len(lowercase       ) / vocoder_sampling_rate == 0.032
       def 					A   (			self		:			Union[str, Any]       ):



           '''simple docstring'''

           UpperCAmelCase     =	self.get_dummy_components()
           UpperCAmelCase     =	AudioLDMPipeline(**lowercase       )
           UpperCAmelCase     =	audioldm_pipe.to(lowercase       )
           audioldm_pipe.set_progress_bar_config(disable=lowercase       )

           UpperCAmelCase     =	['''hey''']

           UpperCAmelCase     =	audioldm_pipe(lowercase     ,       num_inference_steps=1       )
           UpperCAmelCase     =	output.audios.shape
           assert audio_shape == (1, 256)

           UpperCAmelCase     =	audioldm_pipe.vocoder.config
           config.model_in_dim *= 2
           UpperCAmelCase     =	SpeechTaHifiGan(lowercase       ).to(lowercase       )
           UpperCAmelCase     =	audioldm_pipe(lowercase     ,       num_inference_steps=1       )
           UpperCAmelCase     =	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 					A   (			self		:			Dict       ):



           '''simple docstring'''

           self._test_attention_slicing_forward_pass(test_mean_pixel_difference=lowercase       )
       def 					A   (			self		:			Tuple       ):



           '''simple docstring'''

           self._test_inference_batch_single_identical(test_mean_pixel_difference=lowercase       )







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



           '''simple docstring'''

           self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=lowercase       )






@slow
class     _a						(			unittest.TestCase				):
       def 					A   (			self		:			Optional[int]       ):



           '''simple docstring'''

           super().tearDown()
           gc.collect()
           torch.cuda.empty_cache()
       def 					A   (			self		:			Dict     ,       lowercase		:			List[str]     ,       lowercase		:			Any="cpu"     ,       lowercase		:			List[Any]=torch.floataa     ,       lowercase		:			List[str]=0       ):



           '''simple docstring'''

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



           '''simple docstring'''

           UpperCAmelCase     =	AudioLDMPipeline.from_pretrained('''cvssp/audioldm'''       )
           UpperCAmelCase     =	audioldm_pipe.to(lowercase       )
           audioldm_pipe.set_progress_bar_config(disable=lowercase       )

           UpperCAmelCase     =	self.get_inputs(lowercase       )
           UpperCAmelCase     =	25
           UpperCAmelCase     =	audioldm_pipe(**lowercase       ).audios[0]

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

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







       def 					A   (			self		:			List[Any]       ):



           '''simple docstring'''

           UpperCAmelCase     =	AudioLDMPipeline.from_pretrained('''cvssp/audioldm'''       )
           UpperCAmelCase     =	LMSDiscreteScheduler.from_config(audioldm_pipe.scheduler.config       )
           UpperCAmelCase     =	audioldm_pipe.to(lowercase       )
           audioldm_pipe.set_progress_bar_config(disable=lowercase       )

           UpperCAmelCase     =	self.get_inputs(lowercase       )
           UpperCAmelCase     =	audioldm_pipe(**lowercase       ).audios[0]

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

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










'''simple docstring'''







import warnings

from ...utils import logging
from .image_processing_clip import CLIPImageProcessor


A									=logging.get_logger(__name__)


class     _a						(			__a				):
       def __init__(			self		:			List[str]     ,       *lowercase		:			List[str]     ,       **lowercase		:			Optional[int]       ):



           '''simple docstring'''

           warnings.warn(
               '''The class CLIPFeatureExtractor is deprecated and will be removed in version 5 of Transformers. Please'''
               ''' use CLIPImageProcessor instead.'''     ,       lowercase     ,       )
           super().__init__(*lowercase     ,       **lowercase       )




