






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   lowerCamelCase      (_snake_case ,  unittest.TestCase			):







		'''simple docstring'''



		_snake_case    :    Optional[Any]       						=  AudioLDMPipeline
		_snake_case    :    List[Any]       						=  TEXT_TO_AUDIO_PARAMS
		_snake_case    :    Dict       						=  TEXT_TO_AUDIO_BATCH_PARAMS
		_snake_case    :    int       						=  frozenset(
		    [
		        '''num_inference_steps''',
		        '''num_waveforms_per_prompt''',
		        '''generator''',
		        '''latents''',
		        '''output_type''',
		        '''return_dict''',
		        '''callback''',
		        '''callback_steps''',
		    ]			)



		def 					__UpperCAmelCase			(							self   )	->							str:
							torch.manual_seed(0   )
							UpperCAmelCase_    :      Dict            =						UNetaDConditionModel(
							    block_out_channels=(3_2, 6_4)				,		layers_per_block=2				,		sample_size=3_2				,		in_channels=4				,		out_channels=4				,		down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')				,		up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D')				,		cross_attention_dim=(3_2, 6_4)				,		class_embed_type='simple_projection'				,		projection_class_embeddings_input_dim=3_2				,		class_embeddings_concat=_UpperCamelCase				,		)
							UpperCAmelCase_    :      Union[str, Any]            =						DDIMScheduler(
							    beta_start=0.0_00_85				,		beta_end=0.0_12				,		beta_schedule='scaled_linear'				,		clip_sample=_UpperCamelCase				,		set_alpha_to_one=_UpperCamelCase				,		)
							torch.manual_seed(0   )
							UpperCAmelCase_    :      Optional[Any]            =						AutoencoderKL(
							    block_out_channels=[3_2, 6_4]				,		in_channels=1				,		out_channels=1				,		down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D']				,		up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D']				,		latent_channels=4				,		)
							torch.manual_seed(0   )
							UpperCAmelCase_    :      int            =						ClapTextConfig(
							    bos_token_id=0				,		eos_token_id=2				,		hidden_size=3_2				,		intermediate_size=3_7				,		layer_norm_eps=1E-05				,		num_attention_heads=4				,		num_hidden_layers=5				,		pad_token_id=1				,		vocab_size=1_0_0_0				,		projection_dim=3_2				,		)
							UpperCAmelCase_    :      List[str]            =						ClapTextModelWithProjection(_UpperCamelCase   )
							UpperCAmelCase_    :      Any            =						RobertaTokenizer.from_pretrained('hf-internal-testing/tiny-random-roberta'				,		model_max_length=7_7   )

							UpperCAmelCase_    :      Any            =						SpeechTaHifiGanConfig(
							    model_in_dim=8				,		sampling_rate=1_6_0_0_0				,		upsample_initial_channel=1_6				,		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=_UpperCamelCase				,		)

							UpperCAmelCase_    :      Union[str, Any]            =						SpeechTaHifiGan(_UpperCamelCase   )

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



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



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

							UpperCAmelCase_    :      Any            =						self.get_dummy_components()
							UpperCAmelCase_    :      Any            =						AudioLDMPipeline(**_UpperCamelCase   )
							UpperCAmelCase_    :      List[str]            =						audioldm_pipe.to(_UpperCamelCase   )
							audioldm_pipe.set_progress_bar_config(disable=_UpperCamelCase   )

							UpperCAmelCase_    :      List[str]            =						self.get_dummy_inputs(_UpperCamelCase   )
							UpperCAmelCase_    :      List[Any]            =						audioldm_pipe(**_UpperCamelCase   )
							UpperCAmelCase_    :      Union[str, Any]            =						output.audios[0]

							assert audio.ndim == 1
							assert len(_UpperCamelCase   ) == 2_5_6

							UpperCAmelCase_    :      int            =						audio[:1_0]
							UpperCAmelCase_    :      List[str]            =						np.array(
							    [-0.00_50, 0.00_50, -0.00_60, 0.00_33, -0.00_26, 0.00_33, -0.00_27, 0.00_33, -0.00_28, 0.00_33]   )

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



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

							UpperCAmelCase_    :      Optional[int]            =						self.get_dummy_inputs(_UpperCamelCase   )
							UpperCAmelCase_    :      Tuple            =						3 * [inputs['prompt']]

							# forward
							UpperCAmelCase_    :      Optional[Any]            =						audioldm_pipe(**_UpperCamelCase   )
							UpperCAmelCase_    :      Tuple            =						output.audios[0]

							UpperCAmelCase_    :      Optional[Any]            =						self.get_dummy_inputs(_UpperCamelCase   )
							UpperCAmelCase_    :      str            =						3 * [inputs.pop('prompt'   )]

							UpperCAmelCase_    :      Union[str, Any]            =						audioldm_pipe.tokenizer(
							    _UpperCamelCase				,		padding='max_length'				,		max_length=audioldm_pipe.tokenizer.model_max_length				,		truncation=_UpperCamelCase				,		return_tensors='pt'				,		)
							UpperCAmelCase_    :      str            =						text_inputs['input_ids'].to(_UpperCamelCase   )

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

							UpperCAmelCase_    :      int            =						prompt_embeds

							# forward
							UpperCAmelCase_    :      str            =						audioldm_pipe(**_UpperCamelCase   )
							UpperCAmelCase_    :      Any            =						output.audios[0]

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



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

							UpperCAmelCase_    :      Dict            =						self.get_dummy_inputs(_UpperCamelCase   )
							UpperCAmelCase_    :      List[Any]            =						3 * ['this is a negative prompt']
							UpperCAmelCase_    :      Optional[int]            =						negative_prompt
							UpperCAmelCase_    :      Any            =						3 * [inputs['prompt']]

							# forward
							UpperCAmelCase_    :      Optional[Any]            =						audioldm_pipe(**_UpperCamelCase   )
							UpperCAmelCase_    :      Optional[Any]            =						output.audios[0]

							UpperCAmelCase_    :      Any            =						self.get_dummy_inputs(_UpperCamelCase   )
							UpperCAmelCase_    :      Union[str, Any]            =						3 * [inputs.pop('prompt'   )]

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

												UpperCAmelCase_    :      Optional[int]            =						audioldm_pipe.text_encoder(
												    _UpperCamelCase				,		)
												UpperCAmelCase_    :      List[str]            =						text_embeds.text_embeds
												# additional L_2 normalization over each hidden-state
												UpperCAmelCase_    :      Optional[int]            =						F.normalize(_UpperCamelCase				,		dim=-1   )

												embeds.append(_UpperCamelCase   )

							UpperCAmelCase_       ,  UpperCAmelCase_    :      Tuple            =						embeds

							# forward
							UpperCAmelCase_    :      Union[str, Any]            =						audioldm_pipe(**_UpperCamelCase   )
							UpperCAmelCase_    :      List[str]            =						output.audios[0]

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



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

							UpperCAmelCase_    :      Optional[Any]            =						self.get_dummy_inputs(_UpperCamelCase   )
							UpperCAmelCase_    :      Any            =						'egg cracking'
							UpperCAmelCase_    :      List[Any]            =						audioldm_pipe(**_UpperCamelCase				,		negative_prompt=_UpperCamelCase   )
							UpperCAmelCase_    :      List[Any]            =						output.audios[0]

							assert audio.ndim == 1
							assert len(_UpperCamelCase   ) == 2_5_6

							UpperCAmelCase_    :      List[Any]            =						audio[:1_0]
							UpperCAmelCase_    :      int            =						np.array(
							    [-0.00_51, 0.00_50, -0.00_60, 0.00_34, -0.00_26, 0.00_33, -0.00_27, 0.00_33, -0.00_28, 0.00_32]   )

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



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

							UpperCAmelCase_    :      Optional[int]            =						'A hammer hitting a wooden surface'

							# test num_waveforms_per_prompt=1 (default)
							UpperCAmelCase_    :      int            =						audioldm_pipe(_UpperCamelCase				,		num_inference_steps=2   ).audios

							assert audios.shape == (1, 2_5_6)

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

							assert audios.shape == (batch_size, 2_5_6)

							# test num_waveforms_per_prompt for single prompt
							UpperCAmelCase_    :      List[Any]            =						2
							UpperCAmelCase_    :      Optional[Any]            =						audioldm_pipe(_UpperCamelCase				,		num_inference_steps=2				,		num_waveforms_per_prompt=_UpperCamelCase   ).audios

							assert audios.shape == (num_waveforms_per_prompt, 2_5_6)

							# test num_waveforms_per_prompt for batch of prompts
							UpperCAmelCase_    :      str            =						2
							UpperCAmelCase_    :      int            =						audioldm_pipe(
							    [prompt] * batch_size				,		num_inference_steps=2				,		num_waveforms_per_prompt=_UpperCamelCase   ).audios

							assert audios.shape == (batch_size * num_waveforms_per_prompt, 2_5_6)



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

							UpperCAmelCase_    :      str            =						self.get_dummy_inputs(_UpperCamelCase   )
							UpperCAmelCase_    :      str            =						audioldm_pipe(audio_length_in_s=0.0_16				,		**_UpperCamelCase   )
							UpperCAmelCase_    :      Optional[int]            =						output.audios[0]

							assert audio.ndim == 1
							assert len(_UpperCamelCase   ) / vocoder_sampling_rate == 0.0_16

							UpperCAmelCase_    :      Dict            =						audioldm_pipe(audio_length_in_s=0.0_32				,		**_UpperCamelCase   )
							UpperCAmelCase_    :      int            =						output.audios[0]

							assert audio.ndim == 1
							assert len(_UpperCamelCase   ) / vocoder_sampling_rate == 0.0_32



		def 					__UpperCAmelCase			(							self   )	->							Any:
							UpperCAmelCase_    :      Dict            =						self.get_dummy_components()
							UpperCAmelCase_    :      Optional[int]            =						AudioLDMPipeline(**_UpperCamelCase   )
							UpperCAmelCase_    :      int            =						audioldm_pipe.to(_UpperCamelCase   )
							audioldm_pipe.set_progress_bar_config(disable=_UpperCamelCase   )

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

							UpperCAmelCase_    :      Optional[Any]            =						audioldm_pipe(_UpperCamelCase				,		num_inference_steps=1   )
							UpperCAmelCase_    :      Any            =						output.audios.shape
							assert audio_shape == (1, 2_5_6)

							UpperCAmelCase_    :      Any            =						audioldm_pipe.vocoder.config
							config.model_in_dim *= 2
							UpperCAmelCase_    :      List[str]            =						SpeechTaHifiGan(_UpperCamelCase   ).to(_UpperCamelCase   )
							UpperCAmelCase_    :      List[str]            =						audioldm_pipe(_UpperCamelCase				,		num_inference_steps=1   )
							UpperCAmelCase_    :      str            =						output.audios.shape
							# waveform shape is unchanged, we just have 2x the number of mel channels in the spectrogram
							assert audio_shape == (1, 2_5_6)



		def 					__UpperCAmelCase			(							self   )	->							Optional[int]:
							self._test_attention_slicing_forward_pass(test_mean_pixel_difference=_UpperCamelCase   )



		def 					__UpperCAmelCase			(							self   )	->							Tuple:
							self._test_inference_batch_single_identical(test_mean_pixel_difference=_UpperCamelCase   )



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





@slow
class   lowerCamelCase      (unittest.TestCase			):







		'''simple docstring'''



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



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



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

							UpperCAmelCase_    :      Optional[int]            =						self.get_inputs(_UpperCamelCase   )
							UpperCAmelCase_    :      Tuple            =						2_5
							UpperCAmelCase_    :      Any            =						audioldm_pipe(**_UpperCamelCase   ).audios[0]

							assert audio.ndim == 1
							assert len(_UpperCamelCase   ) == 8_1_9_2_0

							UpperCAmelCase_    :      Union[str, Any]            =						audio[7_7_2_3_0:7_7_2_4_0]
							UpperCAmelCase_    :      List[Any]            =						np.array(
							    [-0.48_84, -0.46_07, 0.00_23, 0.50_07, 0.58_96, 0.51_51, 0.38_13, -0.02_08, -0.36_87, -0.43_15]   )
							UpperCAmelCase_    :      Dict            =						np.abs(expected_slice - audio_slice   ).max()
							assert max_diff < 1E-2



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

							UpperCAmelCase_    :      int            =						self.get_inputs(_UpperCamelCase   )
							UpperCAmelCase_    :      Optional[Any]            =						audioldm_pipe(**_UpperCamelCase   ).audios[0]

							assert audio.ndim == 1
							assert len(_UpperCamelCase   ) == 8_1_9_2_0

							UpperCAmelCase_    :      Dict            =						audio[2_7_7_8_0:2_7_7_9_0]
							UpperCAmelCase_    :      Union[str, Any]            =						np.array([-0.21_31, -0.08_73, -0.01_24, -0.01_89, 0.05_69, 0.13_73, 0.18_83, 0.28_86, 0.32_97, 0.22_12]   )
							UpperCAmelCase_    :      Union[str, Any]            =						np.abs(expected_slice - audio_slice   ).max()
							assert max_diff < 3E-2














from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


__UpperCAmelCase								=						{
    'configuration_time_series_transformer': [
        'TIME_SERIES_TRANSFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP',
        'TimeSeriesTransformerConfig',
    ],
}

try:
		if not is_torch_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		__UpperCAmelCase								=						[
		    'TIME_SERIES_TRANSFORMER_PRETRAINED_MODEL_ARCHIVE_LIST',
		    'TimeSeriesTransformerForPrediction',
		    'TimeSeriesTransformerModel',
		    'TimeSeriesTransformerPreTrainedModel',
		]


if TYPE_CHECKING:
		from .configuration_time_series_transformer import (
		    TIME_SERIES_TRANSFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP,
		    TimeSeriesTransformerConfig,
		)

		try:
				if not is_torch_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_time_series_transformer import (
				    TIME_SERIES_TRANSFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
				    TimeSeriesTransformerForPrediction,
				    TimeSeriesTransformerModel,
				    TimeSeriesTransformerPreTrainedModel,
				)

else:
		import sys

		__UpperCAmelCase								=						_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)






