


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__ (						__magic_name__				,					unittest.TestCase ):
					__SCREAMING_SNAKE_CASE							:	int            = AudioLDMPipeline
					__SCREAMING_SNAKE_CASE							:	int            = TEXT_TO_AUDIO_PARAMS
					__SCREAMING_SNAKE_CASE							:	str            = TEXT_TO_AUDIO_BATCH_PARAMS
					__SCREAMING_SNAKE_CASE							:	List[str]            = frozenset(
					    [
					        'num_inference_steps',
					        'num_waveforms_per_prompt',
					        'generator',
					        'latents',
					        'output_type',
					        'return_dict',
					        'callback',
					        'callback_steps',
					    ] )

					def 	UpperCAmelCase__							(  self							: Optional[int]							):






										'''simple docstring'''






										torch.manual_seed(0							)
										lowercase_					=      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_				,       )
										lowercase_					=      DDIMScheduler(
										    beta_start=0.00_085				,       beta_end=0.012				,       beta_schedule="""scaled_linear"""				,       clip_sample=lowercase_				,       set_alpha_to_one=lowercase_				,       )
										torch.manual_seed(0							)
										lowercase_					=      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							)
										lowercase_					=      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=1_000				,       projection_dim=32				,       )
										lowercase_					=      ClapTextModelWithProjection(lowercase_							)
										lowercase_					=      RobertaTokenizer.from_pretrained("""hf-internal-testing/tiny-random-roberta"""				,       model_max_length=77							)

										lowercase_					=      SpeechTaHifiGanConfig(
										    model_in_dim=8				,       sampling_rate=16_000				,       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_				,       )

										lowercase_					=      SpeechTaHifiGan(lowercase_							)

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

					def 	UpperCAmelCase__							(  self							: Optional[int]				,       UpperCamelCase__							: int				,       UpperCamelCase__							: int=0							):






										'''simple docstring'''






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

					def 	UpperCAmelCase__							(  self							: List[str]							):






										'''simple docstring'''






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

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

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

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

										lowercase_					=      audio[:10]
										lowercase_					=      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							: List[str]							):






										'''simple docstring'''






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

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

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

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

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

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

										lowercase_					=      prompt_embeds

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

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

					def 	UpperCAmelCase__							(  self							: List[str]							):






										'''simple docstring'''






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

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

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

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

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

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

															embeds.append(lowercase_							)

										lowercase_				,       lowercase_					=      embeds

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

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

					def 	UpperCAmelCase__							(  self							: Tuple							):






										'''simple docstring'''






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

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

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

										lowercase_					=      audio[:10]
										lowercase_					=      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							: Union[str, Any]							):






										'''simple docstring'''






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

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

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

										assert audios.shape == (1, 256)

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

										assert audios.shape == (batch_size, 256)

										# test num_waveforms_per_prompt for single prompt
										lowercase_					=      2
										lowercase_					=      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
										lowercase_					=      2
										lowercase_					=      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 	UpperCAmelCase__							(  self							: List[str]							):






										'''simple docstring'''






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

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

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

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

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

					def 	UpperCAmelCase__							(  self							: Dict							):






										'''simple docstring'''






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

										lowercase_					=      ["""hey"""]

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

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






										'''simple docstring'''






										self._test_attention_slicing_forward_pass(test_mean_pixel_difference=lowercase_							)

					def 	UpperCAmelCase__							(  self							: List[Any]							):






										'''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 	UpperCAmelCase__							(  self							: Optional[Any]							):






										'''simple docstring'''






										self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=lowercase_							)







@slow
class 							UpperCamelCase__ (						unittest.TestCase ):

					def 	UpperCAmelCase__							(  self							: str							):






										'''simple docstring'''






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

					def 	UpperCAmelCase__							(  self							: List[Any]				,       UpperCamelCase__							: List[str]				,       UpperCamelCase__							: List[str]="cpu"				,       UpperCamelCase__							: int=torch.floataa				,       UpperCamelCase__							: Tuple=0							):






										'''simple docstring'''






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

					def 	UpperCAmelCase__							(  self							: List[Any]							):






										'''simple docstring'''






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

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

										assert audio.ndim == 1
										assert len(lowercase_							) == 81_920

										lowercase_					=      audio[77_230:77_240]
										lowercase_					=      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]							)
										lowercase_					=      np.abs(expected_slice - audio_slice							).max()
										assert max_diff < 1e-2







					def 	UpperCAmelCase__							(  self							: str							):






										'''simple docstring'''






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

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

										assert audio.ndim == 1
										assert len(lowercase_							) == 81_920

										lowercase_					=      audio[27_780:27_790]
										lowercase_					=      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]							)
										lowercase_					=      np.abs(expected_slice - audio_slice							).max()
										assert max_diff < 3e-2



def 				lowerCAmelCase__       (			a__ )      ->int:




  '''simple docstring'''

  if not isinstance(a__    ,     a__ ) or number < 0:
    raise ValueError("Input must be a non-negative integer" )

  _UpperCamelCase           =    0
  while number:
    # This way we arrive at next set bit (next 1) instead of looping
    # through each bit and checking for 1s hence the
    # loop won't run 32 times it will only run the number of `1` times
    number &= number - 1
    count += 1
  return count


if __name__ == "__main__":
   import doctest

   doctest.testmod()




