

'''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  UpperCAmelCase (							UpperCAmelCase__  , unittest.TestCase    ):

		'''simple docstring'''






		SCREAMING_SNAKE_CASE_           =					AudioLDMPipeline
		SCREAMING_SNAKE_CASE_           =					TEXT_TO_AUDIO_PARAMS
		SCREAMING_SNAKE_CASE_           =					TEXT_TO_AUDIO_BATCH_PARAMS
		SCREAMING_SNAKE_CASE_           =					frozenset(
		    [
		        'num_inference_steps',
		        'num_waveforms_per_prompt',
		        'generator',
		        'latents',
		        'output_type',
		        'return_dict',
		        'callback',
		        'callback_steps',
		    ]    )
		def 			UpperCamelCase(					self		)  ->     List[str]:






							'''simple docstring'''



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

							lowerCamelCase_  				=      SpeechTaHifiGanConfig(
							    model_in_dim=8   ,			sampling_rate=16000   ,			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=SCREAMING_SNAKE_CASE_   ,			)

							lowerCamelCase_  				=      SpeechTaHifiGan(SCREAMING_SNAKE_CASE_		)

							lowerCamelCase_  				=      {
							    'unet': unet,
							    'scheduler': scheduler,
							    'vae': vae,
							    'text_encoder': text_encoder,
							    'tokenizer': tokenizer,
							    'vocoder': vocoder,
							}
							return components
		def 			UpperCamelCase(					self   ,			SCREAMING_SNAKE_CASE_   ,			SCREAMING_SNAKE_CASE_=0		)  ->     Optional[Any]:






							'''simple docstring'''



							if str(SCREAMING_SNAKE_CASE_		).startswith('mps'		):
												lowerCamelCase_  				=      torch.manual_seed(SCREAMING_SNAKE_CASE_		)
							else:
												lowerCamelCase_  				=      torch.Generator(device=SCREAMING_SNAKE_CASE_		).manual_seed(SCREAMING_SNAKE_CASE_		)
							lowerCamelCase_  				=      {
							    'prompt': 'A hammer hitting a wooden surface',
							    'generator': generator,
							    'num_inference_steps': 2,
							    'guidance_scale': 6.0,
							}
							return inputs
		def 			UpperCamelCase(					self		)  ->     str:






							'''simple docstring'''



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

							lowerCamelCase_  				=      self.get_dummy_components()
							lowerCamelCase_  				=      AudioLDMPipeline(**SCREAMING_SNAKE_CASE_		)
							lowerCamelCase_  				=      audioldm_pipe.to(SCREAMING_SNAKE_CASE_		)
							audioldm_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_		)

							lowerCamelCase_  				=      self.get_dummy_inputs(SCREAMING_SNAKE_CASE_		)
							lowerCamelCase_  				=      audioldm_pipe(**SCREAMING_SNAKE_CASE_		)
							lowerCamelCase_  				=      output.audios[0]

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

							lowerCamelCase_  				=      audio[:10]
							lowerCamelCase_  				=      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 			UpperCamelCase(					self		)  ->     Tuple:






							'''simple docstring'''



							lowerCamelCase_  				=      self.get_dummy_components()
							lowerCamelCase_  				=      AudioLDMPipeline(**SCREAMING_SNAKE_CASE_		)
							lowerCamelCase_  				=      audioldm_pipe.to(SCREAMING_SNAKE_CASE_		)
							lowerCamelCase_  				=      audioldm_pipe.to(SCREAMING_SNAKE_CASE_		)
							audioldm_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_		)

							lowerCamelCase_  				=      self.get_dummy_inputs(SCREAMING_SNAKE_CASE_		)
							lowerCamelCase_  				=      3 * [inputs['prompt']]

							# forward
							lowerCamelCase_  				=      audioldm_pipe(**SCREAMING_SNAKE_CASE_		)
							lowerCamelCase_  				=      output.audios[0]

							lowerCamelCase_  				=      self.get_dummy_inputs(SCREAMING_SNAKE_CASE_		)
							lowerCamelCase_  				=      3 * [inputs.pop('prompt'		)]

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

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

							lowerCamelCase_  				=      prompt_embeds

							# forward
							lowerCamelCase_  				=      audioldm_pipe(**SCREAMING_SNAKE_CASE_		)
							lowerCamelCase_  				=      output.audios[0]

							assert np.abs(audio_a - audio_a		).max() < 1E-2
		def 			UpperCamelCase(					self		)  ->     List[Any]:






							'''simple docstring'''



							lowerCamelCase_  				=      self.get_dummy_components()
							lowerCamelCase_  				=      AudioLDMPipeline(**SCREAMING_SNAKE_CASE_		)
							lowerCamelCase_  				=      audioldm_pipe.to(SCREAMING_SNAKE_CASE_		)
							lowerCamelCase_  				=      audioldm_pipe.to(SCREAMING_SNAKE_CASE_		)
							audioldm_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_		)

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

							# forward
							lowerCamelCase_  				=      audioldm_pipe(**SCREAMING_SNAKE_CASE_		)
							lowerCamelCase_  				=      output.audios[0]

							lowerCamelCase_  				=      self.get_dummy_inputs(SCREAMING_SNAKE_CASE_		)
							lowerCamelCase_  				=      3 * [inputs.pop('prompt'		)]

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

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

												embeds.append(SCREAMING_SNAKE_CASE_		)

							lowerCamelCase_				,lowerCamelCase_  				=      embeds

							# forward
							lowerCamelCase_  				=      audioldm_pipe(**SCREAMING_SNAKE_CASE_		)
							lowerCamelCase_  				=      output.audios[0]

							assert np.abs(audio_a - audio_a		).max() < 1E-2
		def 			UpperCamelCase(					self		)  ->     Any:






							'''simple docstring'''



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

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

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

							lowerCamelCase_  				=      audio[:10]
							lowerCamelCase_  				=      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 			UpperCamelCase(					self		)  ->     Tuple:






							'''simple docstring'''



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

							lowerCamelCase_  				=      'A hammer hitting a wooden surface'

							# test num_waveforms_per_prompt=1 (default)
							lowerCamelCase_  				=      audioldm_pipe(SCREAMING_SNAKE_CASE_   ,			num_inference_steps=2		).audios

							assert audios.shape == (1, 256)

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

							assert audios.shape == (batch_size, 256)

							# test num_waveforms_per_prompt for single prompt
							lowerCamelCase_  				=      2
							lowerCamelCase_  				=      audioldm_pipe(SCREAMING_SNAKE_CASE_   ,			num_inference_steps=2   ,			num_waveforms_per_prompt=SCREAMING_SNAKE_CASE_		).audios

							assert audios.shape == (num_waveforms_per_prompt, 256)

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

							assert audios.shape == (batch_size * num_waveforms_per_prompt, 256)
		def 			UpperCamelCase(					self		)  ->     str:






							'''simple docstring'''



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

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

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

							lowerCamelCase_  				=      audioldm_pipe(audio_length_in_s=0.032   ,			**SCREAMING_SNAKE_CASE_		)
							lowerCamelCase_  				=      output.audios[0]

							assert audio.ndim == 1
							assert len(SCREAMING_SNAKE_CASE_		) / vocoder_sampling_rate == 0.032
		def 			UpperCamelCase(					self		)  ->     Union[str, Any]:






							'''simple docstring'''



							lowerCamelCase_  				=      self.get_dummy_components()
							lowerCamelCase_  				=      AudioLDMPipeline(**SCREAMING_SNAKE_CASE_		)
							lowerCamelCase_  				=      audioldm_pipe.to(SCREAMING_SNAKE_CASE_		)
							audioldm_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_		)

							lowerCamelCase_  				=      ['hey']

							lowerCamelCase_  				=      audioldm_pipe(SCREAMING_SNAKE_CASE_   ,			num_inference_steps=1		)
							lowerCamelCase_  				=      output.audios.shape
							assert audio_shape == (1, 256)

							lowerCamelCase_  				=      audioldm_pipe.vocoder.config
							config.model_in_dim *= 2
							lowerCamelCase_  				=      SpeechTaHifiGan(SCREAMING_SNAKE_CASE_		).to(SCREAMING_SNAKE_CASE_		)
							lowerCamelCase_  				=      audioldm_pipe(SCREAMING_SNAKE_CASE_   ,			num_inference_steps=1		)
							lowerCamelCase_  				=      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 			UpperCamelCase(					self		)  ->     Union[str, Any]:






							'''simple docstring'''



							self._test_attention_slicing_forward_pass(test_mean_pixel_difference=SCREAMING_SNAKE_CASE_		)
		def 			UpperCamelCase(					self		)  ->     Optional[int]:






							'''simple docstring'''



							self._test_inference_batch_single_identical(test_mean_pixel_difference=SCREAMING_SNAKE_CASE_		)






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






							'''simple docstring'''



							self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=SCREAMING_SNAKE_CASE_		)


@slow
class  UpperCAmelCase (							unittest.TestCase    ):

		'''simple docstring'''






		def 			UpperCamelCase(					self		)  ->     Union[str, Any]:






							'''simple docstring'''



							super().tearDown()
							gc.collect()
							torch.cuda.empty_cache()
		def 			UpperCamelCase(					self   ,			SCREAMING_SNAKE_CASE_   ,			SCREAMING_SNAKE_CASE_="cpu"   ,			SCREAMING_SNAKE_CASE_=torch.floataa   ,			SCREAMING_SNAKE_CASE_=0		)  ->     int:






							'''simple docstring'''



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






							'''simple docstring'''



							lowerCamelCase_  				=      AudioLDMPipeline.from_pretrained('cvssp/audioldm'		)
							lowerCamelCase_  				=      audioldm_pipe.to(SCREAMING_SNAKE_CASE_		)
							audioldm_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_		)

							lowerCamelCase_  				=      self.get_inputs(SCREAMING_SNAKE_CASE_		)
							lowerCamelCase_  				=      25
							lowerCamelCase_  				=      audioldm_pipe(**SCREAMING_SNAKE_CASE_		).audios[0]

							assert audio.ndim == 1
							assert len(SCREAMING_SNAKE_CASE_		) == 81920

							lowerCamelCase_  				=      audio[77230:77240]
							lowerCamelCase_  				=      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]		)
							lowerCamelCase_  				=      np.abs(expected_slice - audio_slice		).max()
							assert max_diff < 1E-2






		def 			UpperCamelCase(					self		)  ->     List[str]:






							'''simple docstring'''



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

							lowerCamelCase_  				=      self.get_inputs(SCREAMING_SNAKE_CASE_		)
							lowerCamelCase_  				=      audioldm_pipe(**SCREAMING_SNAKE_CASE_		).audios[0]

							assert audio.ndim == 1
							assert len(SCREAMING_SNAKE_CASE_		) == 81920

							lowerCamelCase_  				=      audio[27780:27790]
							lowerCamelCase_  				=      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]		)
							lowerCamelCase_  				=      np.abs(expected_slice - audio_slice		).max()
							assert max_diff < 3E-2




"""simple docstring"""



def  _A(		lowerCAmelCase			,  lowerCAmelCase							):
							A__       :     List[Any]								=			[1]
							for i in range(2			,  lowerCAmelCase							):
														factorials.append(factorials[-1] * i							)
							assert 0 <= k < factorials[-1] * n, "k out of bounds"

							A__       :     Union[str, Any]								=			[]
							A__       :     int								=			list(range(lowerCAmelCase							)							)

							# Find permutation
							while factorials:
														A__       :     Optional[int]								=			factorials.pop()
														A__				,							A__       :     Union[str, Any]								=			divmod(lowerCAmelCase			,  lowerCAmelCase							)
														permutation.append(elements[number]							)
														elements.remove(elements[number]							)
							permutation.append(elements[0]							)

							return permutation


if __name__ == "__main__":
				import doctest

				doctest.testmod()





