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


			'''simple docstring'''






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



			def 							a_       (   self):




					"""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=__lowerCAmelCase       ,    )
					lowerCAmelCase   					=  DDIMScheduler(
					    beta_start=0.00085       ,    beta_end=0.012       ,    beta_schedule="""scaled_linear"""       ,    clip_sample=__lowerCAmelCase       ,    set_alpha_to_one=__lowerCAmelCase       ,    )
					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-0_5       ,    num_attention_heads=4       ,    num_hidden_layers=5       ,    pad_token_id=1       ,    vocab_size=1000       ,    projection_dim=32       ,    )
					lowerCAmelCase   					=  ClapTextModelWithProjection(__lowerCAmelCase)
					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=__lowerCAmelCase       ,    )

					lowerCAmelCase   					=  SpeechTaHifiGan(__lowerCAmelCase)

					lowerCAmelCase   					=  {
					    """unet""": unet,
					    """scheduler""": scheduler,
					    """vae""": vae,
					    """text_encoder""": text_encoder,
					    """tokenizer""": tokenizer,
					    """vocoder""": vocoder,
					}
					return components



			def 							a_       (   self       ,    __lowerCAmelCase       ,    __lowerCAmelCase=0):




					"""simple docstring"""


					if str(__lowerCAmelCase).startswith("""mps"""):
							lowerCAmelCase   					=  torch.manual_seed(__lowerCAmelCase)
					else:
							lowerCAmelCase   					=  torch.Generator(device=__lowerCAmelCase).manual_seed(__lowerCAmelCase)
					lowerCAmelCase   					=  {
					    """prompt""": """A hammer hitting a wooden surface""",
					    """generator""": generator,
					    """num_inference_steps""": 2,
					    """guidance_scale""": 6.0,
					}
					return inputs



			def 							a_       (   self):




					"""simple docstring"""


					lowerCAmelCase   					=  """cpu"""  # ensure determinism for the device-dependent torch.Generator

					lowerCAmelCase   					=  self.get_dummy_components()
					lowerCAmelCase   					=  AudioLDMPipeline(**__lowerCAmelCase)
					lowerCAmelCase   					=  audioldm_pipe.to(__lowerCAmelCase)
					audioldm_pipe.set_progress_bar_config(disable=__lowerCAmelCase)

					lowerCAmelCase   					=  self.get_dummy_inputs(__lowerCAmelCase)
					lowerCAmelCase   					=  audioldm_pipe(**__lowerCAmelCase)
					lowerCAmelCase   					=  output.audios[0]

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

					lowerCAmelCase   					=  audio[:10]
					lowerCAmelCase   					=  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):




					"""simple docstring"""


					lowerCAmelCase   					=  self.get_dummy_components()
					lowerCAmelCase   					=  AudioLDMPipeline(**__lowerCAmelCase)
					lowerCAmelCase   					=  audioldm_pipe.to(__lowerCAmelCase)
					lowerCAmelCase   					=  audioldm_pipe.to(__lowerCAmelCase)
					audioldm_pipe.set_progress_bar_config(disable=__lowerCAmelCase)

					lowerCAmelCase   					=  self.get_dummy_inputs(__lowerCAmelCase)
					lowerCAmelCase   					=  3 * [inputs["""prompt"""]]

					# forward
					lowerCAmelCase   					=  audioldm_pipe(**__lowerCAmelCase)
					lowerCAmelCase   					=  output.audios[0]

					lowerCAmelCase   					=  self.get_dummy_inputs(__lowerCAmelCase)
					lowerCAmelCase   					=  3 * [inputs.pop("""prompt""")]

					lowerCAmelCase   					=  audioldm_pipe.tokenizer(
					    __lowerCAmelCase       ,    padding="""max_length"""       ,    max_length=audioldm_pipe.tokenizer.model_max_length       ,    truncation=__lowerCAmelCase       ,    return_tensors="""pt"""       ,    )
					lowerCAmelCase   					=  text_inputs["""input_ids"""].to(__lowerCAmelCase)

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

					lowerCAmelCase   					=  prompt_embeds

					# forward
					lowerCAmelCase   					=  audioldm_pipe(**__lowerCAmelCase)
					lowerCAmelCase   					=  output.audios[0]

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



			def 							a_       (   self):




					"""simple docstring"""


					lowerCAmelCase   					=  self.get_dummy_components()
					lowerCAmelCase   					=  AudioLDMPipeline(**__lowerCAmelCase)
					lowerCAmelCase   					=  audioldm_pipe.to(__lowerCAmelCase)
					lowerCAmelCase   					=  audioldm_pipe.to(__lowerCAmelCase)
					audioldm_pipe.set_progress_bar_config(disable=__lowerCAmelCase)

					lowerCAmelCase   					=  self.get_dummy_inputs(__lowerCAmelCase)
					lowerCAmelCase   					=  3 * ["""this is a negative prompt"""]
					lowerCAmelCase   					=  negative_prompt
					lowerCAmelCase   					=  3 * [inputs["""prompt"""]]

					# forward
					lowerCAmelCase   					=  audioldm_pipe(**__lowerCAmelCase)
					lowerCAmelCase   					=  output.audios[0]

					lowerCAmelCase   					=  self.get_dummy_inputs(__lowerCAmelCase)
					lowerCAmelCase   					=  3 * [inputs.pop("""prompt""")]

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

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

							embeds.append(__lowerCAmelCase)

					lowerCAmelCase					,     lowerCAmelCase   					=  embeds

					# forward
					lowerCAmelCase   					=  audioldm_pipe(**__lowerCAmelCase)
					lowerCAmelCase   					=  output.audios[0]

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



			def 							a_       (   self):




					"""simple docstring"""


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

					lowerCAmelCase   					=  self.get_dummy_inputs(__lowerCAmelCase)
					lowerCAmelCase   					=  """egg cracking"""
					lowerCAmelCase   					=  audioldm_pipe(**__lowerCAmelCase       ,    negative_prompt=__lowerCAmelCase)
					lowerCAmelCase   					=  output.audios[0]

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

					lowerCAmelCase   					=  audio[:10]
					lowerCAmelCase   					=  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):




					"""simple docstring"""


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

					lowerCAmelCase   					=  """A hammer hitting a wooden surface"""

					# test num_waveforms_per_prompt=1 (default)
					lowerCAmelCase   					=  audioldm_pipe(__lowerCAmelCase       ,    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(__lowerCAmelCase       ,    num_inference_steps=2       ,    num_waveforms_per_prompt=__lowerCAmelCase).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=__lowerCAmelCase).audios

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



			def 							a_       (   self):




					"""simple docstring"""


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

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

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

					lowerCAmelCase   					=  audioldm_pipe(audio_length_in_s=0.032       ,    **__lowerCAmelCase)
					lowerCAmelCase   					=  output.audios[0]

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



			def 							a_       (   self):




					"""simple docstring"""


					lowerCAmelCase   					=  self.get_dummy_components()
					lowerCAmelCase   					=  AudioLDMPipeline(**__lowerCAmelCase)
					lowerCAmelCase   					=  audioldm_pipe.to(__lowerCAmelCase)
					audioldm_pipe.set_progress_bar_config(disable=__lowerCAmelCase)

					lowerCAmelCase   					=  ["""hey"""]

					lowerCAmelCase   					=  audioldm_pipe(__lowerCAmelCase       ,    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(__lowerCAmelCase).to(__lowerCAmelCase)
					lowerCAmelCase   					=  audioldm_pipe(__lowerCAmelCase       ,    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 							a_       (   self):




					"""simple docstring"""


					self._test_attention_slicing_forward_pass(test_mean_pixel_difference=__lowerCAmelCase)



			def 							a_       (   self):




					"""simple docstring"""


					self._test_inference_batch_single_identical(test_mean_pixel_difference=__lowerCAmelCase)







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




					"""simple docstring"""


					self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=__lowerCAmelCase)







@slow
class 				a__(					unittest.TestCase	):


			'''simple docstring'''






			def 							a_       (   self):




					"""simple docstring"""


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



			def 							a_       (   self       ,    __lowerCAmelCase       ,    __lowerCAmelCase="cpu"       ,    __lowerCAmelCase=torch.floataa       ,    __lowerCAmelCase=0):




					"""simple docstring"""


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



			def 							a_       (   self):




					"""simple docstring"""


					lowerCAmelCase   					=  AudioLDMPipeline.from_pretrained("""cvssp/audioldm""")
					lowerCAmelCase   					=  audioldm_pipe.to(__lowerCAmelCase)
					audioldm_pipe.set_progress_bar_config(disable=__lowerCAmelCase)

					lowerCAmelCase   					=  self.get_inputs(__lowerCAmelCase)
					lowerCAmelCase   					=  25
					lowerCAmelCase   					=  audioldm_pipe(**__lowerCAmelCase).audios[0]

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

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







			def 							a_       (   self):




					"""simple docstring"""


					lowerCAmelCase   					=  AudioLDMPipeline.from_pretrained("""cvssp/audioldm""")
					lowerCAmelCase   					=  LMSDiscreteScheduler.from_config(audioldm_pipe.scheduler.config)
					lowerCAmelCase   					=  audioldm_pipe.to(__lowerCAmelCase)
					audioldm_pipe.set_progress_bar_config(disable=__lowerCAmelCase)

					lowerCAmelCase   					=  self.get_inputs(__lowerCAmelCase)
					lowerCAmelCase   					=  audioldm_pipe(**__lowerCAmelCase).audios[0]

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

					lowerCAmelCase   					=  audio[27780:27790]
					lowerCAmelCase   					=  np.array([-0.2131, -0.0873, -0.0124, -0.0189, 0.0569, 0.1373, 0.1883, 0.2886, 0.3297, 0.2212])
					lowerCAmelCase   					=  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_flax_available,
    is_tf_available,
    is_torch_available,
)


__lowercase          =  {
    '''configuration_resnet''': ['''RESNET_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''ResNetConfig''', '''ResNetOnnxConfig''']
}

try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						__lowercase          =  [
						    '''RESNET_PRETRAINED_MODEL_ARCHIVE_LIST''',
						    '''ResNetForImageClassification''',
						    '''ResNetModel''',
						    '''ResNetPreTrainedModel''',
						    '''ResNetBackbone''',
						]

try:
						if not is_tf_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						__lowercase          =  [
						    '''TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST''',
						    '''TFResNetForImageClassification''',
						    '''TFResNetModel''',
						    '''TFResNetPreTrainedModel''',
						]

try:
						if not is_flax_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						__lowercase          =  [
						    '''FlaxResNetForImageClassification''',
						    '''FlaxResNetModel''',
						    '''FlaxResNetPreTrainedModel''',
						]

if TYPE_CHECKING:
						from .configuration_resnet import RESNET_PRETRAINED_CONFIG_ARCHIVE_MAP, ResNetConfig, ResNetOnnxConfig

						try:
												if not is_torch_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_resnet import (
												    RESNET_PRETRAINED_MODEL_ARCHIVE_LIST,
												    ResNetBackbone,
												    ResNetForImageClassification,
												    ResNetModel,
												    ResNetPreTrainedModel,
												)

						try:
												if not is_tf_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_tf_resnet import (
												    TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST,
												    TFResNetForImageClassification,
												    TFResNetModel,
												    TFResNetPreTrainedModel,
												)

						try:
												if not is_flax_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_flax_resnet import FlaxResNetForImageClassification, FlaxResNetModel, FlaxResNetPreTrainedModel


else:
						import sys

						__lowercase          =  _LazyModule(__name__, globals()['''__file__'''], _import_structure)




