


'''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 ):


     """simple docstring"""






     SCREAMING_SNAKE_CASE :				Tuple							     =     AudioLDMPipeline
     SCREAMING_SNAKE_CASE :				str							     =     TEXT_TO_AUDIO_PARAMS
     SCREAMING_SNAKE_CASE :				str							     =     TEXT_TO_AUDIO_BATCH_PARAMS
     SCREAMING_SNAKE_CASE :				Union[str, Any]							     =     frozenset(
         [
             "num_inference_steps",
             "num_waveforms_per_prompt",
             "generator",
             "latents",
             "output_type",
             "return_dict",
             "callback",
             "callback_steps",
         ] )

     def 				lowerCamelCase__				(       self  :	List[str]    )		->							Union[str, Any]:
          torch.manual_seed(0    )
          __UpperCAmelCase			:				Optional[int]													=    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=snake_case							,				)
          __UpperCAmelCase			:				Tuple													=    DDIMScheduler(
              beta_start=0.00_085							,				beta_end=0.012							,				beta_schedule='''scaled_linear'''							,				clip_sample=snake_case							,				set_alpha_to_one=snake_case							,				)
          torch.manual_seed(0    )
          __UpperCAmelCase			:				Union[str, Any]													=    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			:				List[str]													=    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=1000							,				projection_dim=32							,				)
          __UpperCAmelCase			:				Union[str, Any]													=    ClapTextModelWithProjection(snake_case    )
          __UpperCAmelCase			:				Optional[int]													=    RobertaTokenizer.from_pretrained('''hf-internal-testing/tiny-random-roberta'''							,				model_max_length=77    )

          __UpperCAmelCase			:				Optional[Any]													=    SpeechTaHifiGanConfig(
              model_in_dim=8							,				sampling_rate=1_6000							,				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=snake_case							,				)

          __UpperCAmelCase			:				Any													=    SpeechTaHifiGan(snake_case    )

          __UpperCAmelCase			:				List[Any]													=    {
              '''unet''': unet,
              '''scheduler''': scheduler,
              '''vae''': vae,
              '''text_encoder''': text_encoder,
              '''tokenizer''': tokenizer,
              '''vocoder''': vocoder,
          }
          return components

     def 				lowerCamelCase__				(       self  :	Any							,				snake_case  :	List[Any]							,				snake_case  :	List[str]=0    )		->							Union[str, Any]:
          if str(snake_case    ).startswith('''mps'''    ):
               __UpperCAmelCase			:				Any													=    torch.manual_seed(snake_case    )
          else:
               __UpperCAmelCase			:				List[Any]													=    torch.Generator(device=snake_case    ).manual_seed(snake_case    )
          __UpperCAmelCase			:				int													=    {
              '''prompt''': '''A hammer hitting a wooden surface''',
              '''generator''': generator,
              '''num_inference_steps''': 2,
              '''guidance_scale''': 6.0,
          }
          return inputs

     def 				lowerCamelCase__				(       self  :	Optional[Any]    )		->							Any:
          __UpperCAmelCase			:				Dict													=    '''cpu'''  # ensure determinism for the device-dependent torch.Generator

          __UpperCAmelCase			:				Dict													=    self.get_dummy_components()
          __UpperCAmelCase			:				Union[str, Any]													=    AudioLDMPipeline(**snake_case    )
          __UpperCAmelCase			:				Union[str, Any]													=    audioldm_pipe.to(snake_case    )
          audioldm_pipe.set_progress_bar_config(disable=snake_case    )

          __UpperCAmelCase			:				Tuple													=    self.get_dummy_inputs(snake_case    )
          __UpperCAmelCase			:				Union[str, Any]													=    audioldm_pipe(**snake_case    )
          __UpperCAmelCase			:				str													=    output.audios[0]

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

          __UpperCAmelCase			:				Dict													=    audio[:10]
          __UpperCAmelCase			:				List[Any]													=    np.array(
              [-0.0_050, 0.0_050, -0.0_060, 0.0_033, -0.0_026, 0.0_033, -0.0_027, 0.0_033, -0.0_028, 0.0_033]    )

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

     def 				lowerCamelCase__				(       self  :	Union[str, Any]    )		->							Dict:
          __UpperCAmelCase			:				int													=    self.get_dummy_components()
          __UpperCAmelCase			:				int													=    AudioLDMPipeline(**snake_case    )
          __UpperCAmelCase			:				Any													=    audioldm_pipe.to(snake_case    )
          __UpperCAmelCase			:				Union[str, Any]													=    audioldm_pipe.to(snake_case    )
          audioldm_pipe.set_progress_bar_config(disable=snake_case    )

          __UpperCAmelCase			:				List[str]													=    self.get_dummy_inputs(snake_case    )
          __UpperCAmelCase			:				str													=    3 * [inputs['''prompt''']]

          # forward
          __UpperCAmelCase			:				Union[str, Any]													=    audioldm_pipe(**snake_case    )
          __UpperCAmelCase			:				int													=    output.audios[0]

          __UpperCAmelCase			:				Dict													=    self.get_dummy_inputs(snake_case    )
          __UpperCAmelCase			:				Tuple													=    3 * [inputs.pop('''prompt'''    )]

          __UpperCAmelCase			:				List[Any]													=    audioldm_pipe.tokenizer(
              snake_case							,				padding='''max_length'''							,				max_length=audioldm_pipe.tokenizer.model_max_length							,				truncation=snake_case							,				return_tensors='''pt'''							,				)
          __UpperCAmelCase			:				str													=    text_inputs['''input_ids'''].to(snake_case    )

          __UpperCAmelCase			:				List[str]													=    audioldm_pipe.text_encoder(
              snake_case							,				)
          __UpperCAmelCase			:				int													=    prompt_embeds.text_embeds
          # additional L_2 normalization over each hidden-state
          __UpperCAmelCase			:				Tuple													=    F.normalize(snake_case							,				dim=-1    )

          __UpperCAmelCase			:				Union[str, Any]													=    prompt_embeds

          # forward
          __UpperCAmelCase			:				Tuple													=    audioldm_pipe(**snake_case    )
          __UpperCAmelCase			:				List[Any]													=    output.audios[0]

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

     def 				lowerCamelCase__				(       self  :	Union[str, Any]    )		->							List[Any]:
          __UpperCAmelCase			:				Any													=    self.get_dummy_components()
          __UpperCAmelCase			:				Optional[Any]													=    AudioLDMPipeline(**snake_case    )
          __UpperCAmelCase			:				Optional[Any]													=    audioldm_pipe.to(snake_case    )
          __UpperCAmelCase			:				List[str]													=    audioldm_pipe.to(snake_case    )
          audioldm_pipe.set_progress_bar_config(disable=snake_case    )

          __UpperCAmelCase			:				List[str]													=    self.get_dummy_inputs(snake_case    )
          __UpperCAmelCase			:				List[Any]													=    3 * ['''this is a negative prompt''']
          __UpperCAmelCase			:				int													=    negative_prompt
          __UpperCAmelCase			:				Dict													=    3 * [inputs['''prompt''']]

          # forward
          __UpperCAmelCase			:				List[Any]													=    audioldm_pipe(**snake_case    )
          __UpperCAmelCase			:				List[Any]													=    output.audios[0]

          __UpperCAmelCase			:				List[str]													=    self.get_dummy_inputs(snake_case    )
          __UpperCAmelCase			:				int													=    3 * [inputs.pop('''prompt'''    )]

          __UpperCAmelCase			:				List[Any]													=    []
          for p in [prompt, negative_prompt]:
               __UpperCAmelCase			:				Optional[int]													=    audioldm_pipe.tokenizer(
                   snake_case							,				padding='''max_length'''							,				max_length=audioldm_pipe.tokenizer.model_max_length							,				truncation=snake_case							,				return_tensors='''pt'''							,				)
               __UpperCAmelCase			:				List[str]													=    text_inputs['''input_ids'''].to(snake_case    )

               __UpperCAmelCase			:				List[Any]													=    audioldm_pipe.text_encoder(
                   snake_case							,				)
               __UpperCAmelCase			:				List[Any]													=    text_embeds.text_embeds
               # additional L_2 normalization over each hidden-state
               __UpperCAmelCase			:				List[Any]													=    F.normalize(snake_case							,				dim=-1    )

               embeds.append(snake_case    )

          __UpperCAmelCase							,     __UpperCAmelCase			:				Any													=    embeds

          # forward
          __UpperCAmelCase			:				str													=    audioldm_pipe(**snake_case    )
          __UpperCAmelCase			:				List[Any]													=    output.audios[0]

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

     def 				lowerCamelCase__				(       self  :	Dict    )		->							Optional[Any]:
          __UpperCAmelCase			:				Optional[Any]													=    '''cpu'''  # ensure determinism for the device-dependent torch.Generator
          __UpperCAmelCase			:				Dict													=    self.get_dummy_components()
          __UpperCAmelCase			:				Tuple													=    PNDMScheduler(skip_prk_steps=snake_case    )
          __UpperCAmelCase			:				str													=    AudioLDMPipeline(**snake_case    )
          __UpperCAmelCase			:				Dict													=    audioldm_pipe.to(snake_case    )
          audioldm_pipe.set_progress_bar_config(disable=snake_case    )

          __UpperCAmelCase			:				int													=    self.get_dummy_inputs(snake_case    )
          __UpperCAmelCase			:				Optional[int]													=    '''egg cracking'''
          __UpperCAmelCase			:				Any													=    audioldm_pipe(**snake_case							,				negative_prompt=snake_case    )
          __UpperCAmelCase			:				Tuple													=    output.audios[0]

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

          __UpperCAmelCase			:				str													=    audio[:10]
          __UpperCAmelCase			:				List[Any]													=    np.array(
              [-0.0_051, 0.0_050, -0.0_060, 0.0_034, -0.0_026, 0.0_033, -0.0_027, 0.0_033, -0.0_028, 0.0_032]    )

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

     def 				lowerCamelCase__				(       self  :	Optional[int]    )		->							Optional[int]:
          __UpperCAmelCase			:				str													=    '''cpu'''  # ensure determinism for the device-dependent torch.Generator
          __UpperCAmelCase			:				Union[str, Any]													=    self.get_dummy_components()
          __UpperCAmelCase			:				Optional[Any]													=    PNDMScheduler(skip_prk_steps=snake_case    )
          __UpperCAmelCase			:				Tuple													=    AudioLDMPipeline(**snake_case    )
          __UpperCAmelCase			:				Optional[int]													=    audioldm_pipe.to(snake_case    )
          audioldm_pipe.set_progress_bar_config(disable=snake_case    )

          __UpperCAmelCase			:				str													=    '''A hammer hitting a wooden surface'''

          # test num_waveforms_per_prompt=1 (default)
          __UpperCAmelCase			:				Optional[int]													=    audioldm_pipe(snake_case							,				num_inference_steps=2    ).audios

          assert audios.shape == (1, 256)

          # test num_waveforms_per_prompt=1 (default) for batch of prompts
          __UpperCAmelCase			:				int													=    2
          __UpperCAmelCase			:				int													=    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			:				List[str]													=    2
          __UpperCAmelCase			:				int													=    audioldm_pipe(snake_case							,				num_inference_steps=2							,				num_waveforms_per_prompt=snake_case    ).audios

          assert audios.shape == (num_waveforms_per_prompt, 256)

          # test num_waveforms_per_prompt for batch of prompts
          __UpperCAmelCase			:				Optional[int]													=    2
          __UpperCAmelCase			:				Union[str, Any]													=    audioldm_pipe(
              [prompt] * batch_size							,				num_inference_steps=2							,				num_waveforms_per_prompt=snake_case    ).audios

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

     def 				lowerCamelCase__				(       self  :	List[Any]    )		->							Any:
          __UpperCAmelCase			:				Optional[int]													=    '''cpu'''  # ensure determinism for the device-dependent torch.Generator
          __UpperCAmelCase			:				int													=    self.get_dummy_components()
          __UpperCAmelCase			:				Dict													=    AudioLDMPipeline(**snake_case    )
          __UpperCAmelCase			:				Union[str, Any]													=    audioldm_pipe.to(snake_case    )
          audioldm_pipe.set_progress_bar_config(disable=snake_case    )
          __UpperCAmelCase			:				str													=    audioldm_pipe.vocoder.config.sampling_rate

          __UpperCAmelCase			:				Union[str, Any]													=    self.get_dummy_inputs(snake_case    )
          __UpperCAmelCase			:				Union[str, Any]													=    audioldm_pipe(audio_length_in_s=0.016							,				**snake_case    )
          __UpperCAmelCase			:				Dict													=    output.audios[0]

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

          __UpperCAmelCase			:				List[str]													=    audioldm_pipe(audio_length_in_s=0.032							,				**snake_case    )
          __UpperCAmelCase			:				Tuple													=    output.audios[0]

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

     def 				lowerCamelCase__				(       self  :	Dict    )		->							int:
          __UpperCAmelCase			:				List[str]													=    self.get_dummy_components()
          __UpperCAmelCase			:				Dict													=    AudioLDMPipeline(**snake_case    )
          __UpperCAmelCase			:				Any													=    audioldm_pipe.to(snake_case    )
          audioldm_pipe.set_progress_bar_config(disable=snake_case    )

          __UpperCAmelCase			:				Union[str, Any]													=    ['''hey''']

          __UpperCAmelCase			:				Optional[int]													=    audioldm_pipe(snake_case							,				num_inference_steps=1    )
          __UpperCAmelCase			:				List[Any]													=    output.audios.shape
          assert audio_shape == (1, 256)

          __UpperCAmelCase			:				Any													=    audioldm_pipe.vocoder.config
          config.model_in_dim *= 2
          __UpperCAmelCase			:				Optional[int]													=    SpeechTaHifiGan(snake_case    ).to(snake_case    )
          __UpperCAmelCase			:				Optional[Any]													=    audioldm_pipe(snake_case							,				num_inference_steps=1    )
          __UpperCAmelCase			:				Dict													=    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 				lowerCamelCase__				(       self  :	Dict    )		->							int:
          self._test_attention_slicing_forward_pass(test_mean_pixel_difference=snake_case    )

     def 				lowerCamelCase__				(       self  :	List[Any]    )		->							List[str]:
          self._test_inference_batch_single_identical(test_mean_pixel_difference=snake_case    )






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



@slow
class 			a       (	unittest.TestCase ):


     """simple docstring"""






     def 				lowerCamelCase__				(       self  :	int    )		->							Optional[int]:
          super().tearDown()
          gc.collect()
          torch.cuda.empty_cache()

     def 				lowerCamelCase__				(       self  :	Any							,				snake_case  :	Optional[int]							,				snake_case  :	Union[str, Any]="cpu"							,				snake_case  :	Dict=torch.floataa							,				snake_case  :	Dict=0    )		->							Tuple:
          __UpperCAmelCase			:				List[Any]													=    torch.Generator(device=snake_case    ).manual_seed(snake_case    )
          __UpperCAmelCase			:				int													=    np.random.RandomState(snake_case    ).standard_normal((1, 8, 128, 16)    )
          __UpperCAmelCase			:				Any													=    torch.from_numpy(snake_case    ).to(device=snake_case							,				dtype=snake_case    )
          __UpperCAmelCase			:				Dict													=    {
              '''prompt''': '''A hammer hitting a wooden surface''',
              '''latents''': latents,
              '''generator''': generator,
              '''num_inference_steps''': 3,
              '''guidance_scale''': 2.5,
          }
          return inputs

     def 				lowerCamelCase__				(       self  :	List[str]    )		->							str:
          __UpperCAmelCase			:				str													=    AudioLDMPipeline.from_pretrained('''cvssp/audioldm'''    )
          __UpperCAmelCase			:				str													=    audioldm_pipe.to(snake_case    )
          audioldm_pipe.set_progress_bar_config(disable=snake_case    )

          __UpperCAmelCase			:				List[Any]													=    self.get_inputs(snake_case    )
          __UpperCAmelCase			:				Tuple													=    25
          __UpperCAmelCase			:				int													=    audioldm_pipe(**snake_case    ).audios[0]

          assert audio.ndim == 1
          assert len(snake_case    ) == 8_1920

          __UpperCAmelCase			:				Union[str, Any]													=    audio[7_7230:7_7240]
          __UpperCAmelCase			:				Optional[Any]													=    np.array(
              [-0.4_884, -0.4_607, 0.0_023, 0.5_007, 0.5_896, 0.5_151, 0.3_813, -0.0_208, -0.3_687, -0.4_315]    )
          __UpperCAmelCase			:				Dict													=    np.abs(expected_slice - audio_slice    ).max()
          assert max_diff < 1E-2






     def 				lowerCamelCase__				(       self  :	str    )		->							Dict:
          __UpperCAmelCase			:				Union[str, Any]													=    AudioLDMPipeline.from_pretrained('''cvssp/audioldm'''    )
          __UpperCAmelCase			:				List[Any]													=    LMSDiscreteScheduler.from_config(audioldm_pipe.scheduler.config    )
          __UpperCAmelCase			:				Any													=    audioldm_pipe.to(snake_case    )
          audioldm_pipe.set_progress_bar_config(disable=snake_case    )

          __UpperCAmelCase			:				int													=    self.get_inputs(snake_case    )
          __UpperCAmelCase			:				Tuple													=    audioldm_pipe(**snake_case    ).audios[0]

          assert audio.ndim == 1
          assert len(snake_case    ) == 8_1920

          __UpperCAmelCase			:				Dict													=    audio[2_7780:2_7790]
          __UpperCAmelCase			:				str													=    np.array([-0.2_131, -0.0_873, -0.0_124, -0.0_189, 0.0_569, 0.1_373, 0.1_883, 0.2_886, 0.3_297, 0.2_212]    )
          __UpperCAmelCase			:				str													=    np.abs(expected_slice - audio_slice    ).max()
          assert max_diff < 3E-2



'''simple docstring'''



from __future__ import annotations




def 			_a			(		_lowercase      :			list						):





     '''simple docstring'''






     if not nums:
          raise ValueError('''List is empty'''						)
     return sum(_lowercase						) / len(_lowercase						)


if __name__ == "__main__":
      import doctest

      doctest.testmod()