



"""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 SCREAMING_SNAKE_CASE__					(		__snake_case     ,					unittest.TestCase      ):
	_lowerCAmelCase							=					AudioLDMPipeline
	_lowerCAmelCase							=					TEXT_TO_AUDIO_PARAMS
	_lowerCAmelCase							=					TEXT_TO_AUDIO_BATCH_PARAMS
	_lowerCAmelCase							=					frozenset(
	    [
	        "num_inference_steps",
	        "num_waveforms_per_prompt",
	        "generator",
	        "latents",
	        "output_type",
	        "return_dict",
	        "callback",
	        "callback_steps",
	    ]      )



	def     lowerCAmelCase__(self							):





								'''simple docstring'''

								torch.manual_seed(0							)
								__a		:		Tuple									=       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						,     )
								__a		:		Optional[int]									=       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							)
								__a		:		Optional[int]									=       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							)
								__a		:		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						,     )
								__a		:		Any									=       ClapTextModelWithProjection(_lowercase							)
								__a		:		Optional[int]									=       RobertaTokenizer.from_pretrained("""hf-internal-testing/tiny-random-roberta"""						,     model_max_length=77							)

								__a		:		Tuple									=       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=_lowercase						,     )

								__a		:		int									=       SpeechTaHifiGan(_lowercase							)

								__a		:		Union[str, Any]									=       {
								    """unet""": unet,
								    """scheduler""": scheduler,
								    """vae""": vae,
								    """text_encoder""": text_encoder,
								    """tokenizer""": tokenizer,
								    """vocoder""": vocoder,
								}
								return components



	def     lowerCAmelCase__(self						,     _lowercase						,     _lowercase=0							):





								'''simple docstring'''

								if str(_lowercase							).startswith("""mps"""							):
															__a		:		Any									=       torch.manual_seed(_lowercase							)
								else:
															__a		:		int									=       torch.Generator(device=_lowercase							).manual_seed(_lowercase							)
								__a		:		List[Any]									=       {
								    """prompt""": """A hammer hitting a wooden surface""",
								    """generator""": generator,
								    """num_inference_steps""": 2,
								    """guidance_scale""": 6.0,
								}
								return inputs



	def     lowerCAmelCase__(self							):





								'''simple docstring'''

								__a		:		Optional[Any]									=       """cpu"""  # ensure determinism for the device-dependent torch.Generator

								__a		:		int									=       self.get_dummy_components()
								__a		:		str									=       AudioLDMPipeline(**_lowercase							)
								__a		:		Union[str, Any]									=       audioldm_pipe.to(_lowercase							)
								audioldm_pipe.set_progress_bar_config(disable=_lowercase							)

								__a		:		Union[str, Any]									=       self.get_dummy_inputs(_lowercase							)
								__a		:		Optional[int]									=       audioldm_pipe(**_lowercase							)
								__a		:		Tuple									=       output.audios[0]

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

								__a		:		Union[str, Any]									=       audio[:10]
								__a		:		Dict									=       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     lowerCAmelCase__(self							):





								'''simple docstring'''

								__a		:		List[str]									=       self.get_dummy_components()
								__a		:		List[str]									=       AudioLDMPipeline(**_lowercase							)
								__a		:		Dict									=       audioldm_pipe.to(_lowercase							)
								__a		:		List[str]									=       audioldm_pipe.to(_lowercase							)
								audioldm_pipe.set_progress_bar_config(disable=_lowercase							)

								__a		:		List[str]									=       self.get_dummy_inputs(_lowercase							)
								__a		:		Any									=       3 * [inputs["""prompt"""]]

								# forward
								__a		:		List[str]									=       audioldm_pipe(**_lowercase							)
								__a		:		Tuple									=       output.audios[0]

								__a		:		int									=       self.get_dummy_inputs(_lowercase							)
								__a		:		Optional[Any]									=       3 * [inputs.pop("""prompt"""							)]

								__a		:		str									=       audioldm_pipe.tokenizer(
								    _lowercase						,     padding="""max_length"""						,     max_length=audioldm_pipe.tokenizer.model_max_length						,     truncation=_lowercase						,     return_tensors="""pt"""						,     )
								__a		:		Tuple									=       text_inputs["""input_ids"""].to(_lowercase							)

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

								__a		:		List[Any]									=       prompt_embeds

								# forward
								__a		:		Dict									=       audioldm_pipe(**_lowercase							)
								__a		:		Dict									=       output.audios[0]

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



	def     lowerCAmelCase__(self							):





								'''simple docstring'''

								__a		:		Dict									=       self.get_dummy_components()
								__a		:		Any									=       AudioLDMPipeline(**_lowercase							)
								__a		:		Optional[Any]									=       audioldm_pipe.to(_lowercase							)
								__a		:		Dict									=       audioldm_pipe.to(_lowercase							)
								audioldm_pipe.set_progress_bar_config(disable=_lowercase							)

								__a		:		List[Any]									=       self.get_dummy_inputs(_lowercase							)
								__a		:		Optional[int]									=       3 * ["""this is a negative prompt"""]
								__a		:		Union[str, Any]									=       negative_prompt
								__a		:		Dict									=       3 * [inputs["""prompt"""]]

								# forward
								__a		:		Any									=       audioldm_pipe(**_lowercase							)
								__a		:		Union[str, Any]									=       output.audios[0]

								__a		:		Dict									=       self.get_dummy_inputs(_lowercase							)
								__a		:		Optional[Any]									=       3 * [inputs.pop("""prompt"""							)]

								__a		:		Union[str, Any]									=       []
								for p in [prompt, negative_prompt]:
															__a		:		str									=       audioldm_pipe.tokenizer(
															    _lowercase						,     padding="""max_length"""						,     max_length=audioldm_pipe.tokenizer.model_max_length						,     truncation=_lowercase						,     return_tensors="""pt"""						,     )
															__a		:		Optional[int]									=       text_inputs["""input_ids"""].to(_lowercase							)

															__a		:		Optional[int]									=       audioldm_pipe.text_encoder(
															    _lowercase						,     )
															__a		:		Optional[int]									=       text_embeds.text_embeds
															# additional L_2 normalization over each hidden-state
															__a		:		Tuple									=       F.normalize(_lowercase						,     dim=-1							)

															embeds.append(_lowercase							)

								__a		:		int									=       embeds

								# forward
								__a		:		List[Any]									=       audioldm_pipe(**_lowercase							)
								__a		:		int									=       output.audios[0]

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



	def     lowerCAmelCase__(self							):





								'''simple docstring'''

								__a		:		List[str]									=       """cpu"""  # ensure determinism for the device-dependent torch.Generator
								__a		:		int									=       self.get_dummy_components()
								__a		:		Tuple									=       PNDMScheduler(skip_prk_steps=_lowercase							)
								__a		:		Optional[int]									=       AudioLDMPipeline(**_lowercase							)
								__a		:		Optional[int]									=       audioldm_pipe.to(_lowercase							)
								audioldm_pipe.set_progress_bar_config(disable=_lowercase							)

								__a		:		Optional[int]									=       self.get_dummy_inputs(_lowercase							)
								__a		:		Any									=       """egg cracking"""
								__a		:		Optional[Any]									=       audioldm_pipe(**_lowercase						,     negative_prompt=_lowercase							)
								__a		:		Tuple									=       output.audios[0]

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

								__a		:		List[Any]									=       audio[:10]
								__a		:		Optional[Any]									=       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     lowerCAmelCase__(self							):





								'''simple docstring'''

								__a		:		Dict									=       """cpu"""  # ensure determinism for the device-dependent torch.Generator
								__a		:		str									=       self.get_dummy_components()
								__a		:		Optional[int]									=       PNDMScheduler(skip_prk_steps=_lowercase							)
								__a		:		Any									=       AudioLDMPipeline(**_lowercase							)
								__a		:		Optional[int]									=       audioldm_pipe.to(_lowercase							)
								audioldm_pipe.set_progress_bar_config(disable=_lowercase							)

								__a		:		List[str]									=       """A hammer hitting a wooden surface"""

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

								assert audios.shape == (1, 256)

								# test num_waveforms_per_prompt=1 (default) for batch of prompts
								__a		:		List[str]									=       2
								__a		:		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
								__a		:		str									=       2
								__a		:		Tuple									=       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
								__a		:		List[Any]									=       2
								__a		:		List[Any]									=       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     lowerCAmelCase__(self							):





								'''simple docstring'''

								__a		:		List[str]									=       """cpu"""  # ensure determinism for the device-dependent torch.Generator
								__a		:		str									=       self.get_dummy_components()
								__a		:		Tuple									=       AudioLDMPipeline(**_lowercase							)
								__a		:		int									=       audioldm_pipe.to(_lowercase							)
								audioldm_pipe.set_progress_bar_config(disable=_lowercase							)
								__a		:		Union[str, Any]									=       audioldm_pipe.vocoder.config.sampling_rate

								__a		:		List[str]									=       self.get_dummy_inputs(_lowercase							)
								__a		:		str									=       audioldm_pipe(audio_length_in_s=0.016						,     **_lowercase							)
								__a		:		List[Any]									=       output.audios[0]

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

								__a		:		List[str]									=       audioldm_pipe(audio_length_in_s=0.032						,     **_lowercase							)
								__a		:		Dict									=       output.audios[0]

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



	def     lowerCAmelCase__(self							):





								'''simple docstring'''

								__a		:		str									=       self.get_dummy_components()
								__a		:		Dict									=       AudioLDMPipeline(**_lowercase							)
								__a		:		List[str]									=       audioldm_pipe.to(_lowercase							)
								audioldm_pipe.set_progress_bar_config(disable=_lowercase							)

								__a		:		Optional[int]									=       ["""hey"""]

								__a		:		List[Any]									=       audioldm_pipe(_lowercase						,     num_inference_steps=1							)
								__a		:		List[Any]									=       output.audios.shape
								assert audio_shape == (1, 256)

								__a		:		Union[str, Any]									=       audioldm_pipe.vocoder.config
								config.model_in_dim *= 2
								__a		:		List[Any]									=       SpeechTaHifiGan(_lowercase							).to(_lowercase							)
								__a		:		Dict									=       audioldm_pipe(_lowercase						,     num_inference_steps=1							)
								__a		:		int									=       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							):





								'''simple docstring'''

								self._test_attention_slicing_forward_pass(test_mean_pixel_difference=_lowercase							)



	def     lowerCAmelCase__(self							):





								'''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     lowerCAmelCase__(self							):





								'''simple docstring'''

								self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=_lowercase							)







@slow
class SCREAMING_SNAKE_CASE__					(		unittest.TestCase      ):



	def     lowerCAmelCase__(self							):





								'''simple docstring'''

								super().tearDown()
								gc.collect()
								torch.cuda.empty_cache()



	def     lowerCAmelCase__(self						,     _lowercase						,     _lowercase="cpu"						,     _lowercase=torch.floataa						,     _lowercase=0							):





								'''simple docstring'''

								__a		:		List[Any]									=       torch.Generator(device=_lowercase							).manual_seed(_lowercase							)
								__a		:		int									=       np.random.RandomState(_lowercase							).standard_normal((1, 8, 128, 16)							)
								__a		:		str									=       torch.from_numpy(_lowercase							).to(device=_lowercase						,     dtype=_lowercase							)
								__a		:		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							):





								'''simple docstring'''

								__a		:		Dict									=       AudioLDMPipeline.from_pretrained("""cvssp/audioldm"""							)
								__a		:		Dict									=       audioldm_pipe.to(_lowercase							)
								audioldm_pipe.set_progress_bar_config(disable=_lowercase							)

								__a		:		str									=       self.get_inputs(_lowercase							)
								__a		:		Dict									=       25
								__a		:		Optional[int]									=       audioldm_pipe(**_lowercase							).audios[0]

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

								__a		:		List[Any]									=       audio[77230:77240]
								__a		:		Any									=       np.array(
								    [-0.4884, -0.4607, 0.0023, 0.5007, 0.5896, 0.5151, 0.3813, -0.0208, -0.3687, -0.4315]							)
								__a		:		Optional[Any]									=       np.abs(expected_slice - audio_slice							).max()
								assert max_diff < 1e-2





	def     lowerCAmelCase__(self							):





								'''simple docstring'''

								__a		:		Optional[int]									=       AudioLDMPipeline.from_pretrained("""cvssp/audioldm"""							)
								__a		:		int									=       LMSDiscreteScheduler.from_config(audioldm_pipe.scheduler.config							)
								__a		:		Union[str, Any]									=       audioldm_pipe.to(_lowercase							)
								audioldm_pipe.set_progress_bar_config(disable=_lowercase							)

								__a		:		Optional[int]									=       self.get_inputs(_lowercase							)
								__a		:		Union[str, Any]									=       audioldm_pipe(**_lowercase							).audios[0]

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

								__a		:		int									=       audio[27780:27790]
								__a		:		List[Any]									=       np.array([-0.2131, -0.0873, -0.0124, -0.0189, 0.0569, 0.1373, 0.1883, 0.2886, 0.3297, 0.2212]							)
								__a		:		Dict									=       np.abs(expected_slice - audio_slice							).max()
								assert max_diff < 3e-2






"""simple docstring"""

from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_sentencepiece_available,
    is_tokenizers_available,
    is_torch_available,
)


lowercase__			   =  {
    "configuration_llama": ["LLAMA_PRETRAINED_CONFIG_ARCHIVE_MAP", "LlamaConfig"],
}

try:
	if not is_sentencepiece_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	lowercase__			   =  ["LlamaTokenizer"]

try:
	if not is_tokenizers_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	lowercase__			   =  ["LlamaTokenizerFast"]

try:
	if not is_torch_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	lowercase__			   =  [
	    "LlamaForCausalLM",
	    "LlamaModel",
	    "LlamaPreTrainedModel",
	    "LlamaForSequenceClassification",
	]


if TYPE_CHECKING:
	from .configuration_llama import LLAMA_PRETRAINED_CONFIG_ARCHIVE_MAP, LlamaConfig

	try:
		if not is_sentencepiece_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .tokenization_llama import LlamaTokenizer

	try:
		if not is_tokenizers_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .tokenization_llama_fast import LlamaTokenizerFast

	try:
		if not is_torch_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_llama import LlamaForCausalLM, LlamaForSequenceClassification, LlamaModel, LlamaPreTrainedModel


else:
	import sys

	lowercase__			   =  _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)

