

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



			'''simple docstring'''






			__snake_case        =	AudioLDMPipeline
			__snake_case        =	TEXT_TO_AUDIO_PARAMS
			__snake_case        =	TEXT_TO_AUDIO_BATCH_PARAMS
			__snake_case        =	frozenset(
			    [
			        'num_inference_steps',
			        'num_waveforms_per_prompt',
			        'generator',
			        'latents',
			        'output_type',
			        'return_dict',
			        'callback',
			        'callback_steps',
			    ]						)


			def lowercase__						(				self	:						int			)      ->		List[str]:





									'''simple docstring'''
									torch.manual_seed(0			)
									A__					:       Optional[int]     =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.00085		,      beta_end=0.012		,      beta_schedule="""scaled_linear"""		,      clip_sample=lowercase__		,      set_alpha_to_one=lowercase__		,      )
									torch.manual_seed(0			)
									A__					:       str     =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__					:       List[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=10_00		,      projection_dim=32		,      )
									A__					:       Tuple     =ClapTextModelWithProjection(lowercase__			)
									A__					:       List[str]     =RobertaTokenizer.from_pretrained("""hf-internal-testing/tiny-random-roberta"""		,      model_max_length=77			)

									A__					:       Optional[Any]     =SpeechTaHifiGanConfig(
									    model_in_dim=8		,      sampling_rate=1_60_00		,      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__					:       List[Any]     =SpeechTaHifiGan(lowercase__			)

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


			def lowercase__						(				self	:						Optional[Any]		,      lowerCAmelCase_	:						Optional[int]		,      lowerCAmelCase_	:						Union[str, Any]=0			)      ->		Dict:





									'''simple docstring'''
									if str(lowercase__			).startswith("""mps"""			):
															A__					:       str     =torch.manual_seed(lowercase__			)
									else:
															A__					:       Optional[int]     =torch.Generator(device=lowercase__			).manual_seed(lowercase__			)
									A__					:       Tuple     ={
									    """prompt""": """A hammer hitting a wooden surface""",
									    """generator""": generator,
									    """num_inference_steps""": 2,
									    """guidance_scale""": 6.0,
									}
									return inputs


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





									'''simple docstring'''
									A__					:       Any     ="""cpu"""  # ensure determinism for the device-dependent torch.Generator

									A__					:       List[str]     =self.get_dummy_components()
									A__					:       Any     =AudioLDMPipeline(**lowercase__			)
									A__					:       Optional[Any]     =audioldm_pipe.to(lowercase__			)
									audioldm_pipe.set_progress_bar_config(disable=lowercase__			)

									A__					:       Optional[int]     =self.get_dummy_inputs(lowercase__			)
									A__					:       List[str]     =audioldm_pipe(**lowercase__			)
									A__					:       Dict     =output.audios[0]

									assert audio.ndim == 1
									assert len(lowercase__			) == 2_56

									A__					:       Union[str, Any]     =audio[:10]
									A__					:       Any     =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 lowercase__						(				self	:						Optional[int]			)      ->		Optional[int]:





									'''simple docstring'''
									A__					:       Tuple     =self.get_dummy_components()
									A__					:       Any     =AudioLDMPipeline(**lowercase__			)
									A__					:       Tuple     =audioldm_pipe.to(lowercase__			)
									A__					:       Union[str, Any]     =audioldm_pipe.to(lowercase__			)
									audioldm_pipe.set_progress_bar_config(disable=lowercase__			)

									A__					:       Optional[Any]     =self.get_dummy_inputs(lowercase__			)
									A__					:       Optional[int]     =3 * [inputs["""prompt"""]]

									# forward
									A__					:       int     =audioldm_pipe(**lowercase__			)
									A__					:       Any     =output.audios[0]

									A__					:       Union[str, Any]     =self.get_dummy_inputs(lowercase__			)
									A__					:       int     =3 * [inputs.pop("""prompt"""			)]

									A__					:       Any     =audioldm_pipe.tokenizer(
									    lowercase__		,      padding="""max_length"""		,      max_length=audioldm_pipe.tokenizer.model_max_length		,      truncation=lowercase__		,      return_tensors="""pt"""		,      )
									A__					:       str     =text_inputs["""input_ids"""].to(lowercase__			)

									A__					:       Union[str, Any]     =audioldm_pipe.text_encoder(
									    lowercase__		,      )
									A__					:       Union[str, Any]     =prompt_embeds.text_embeds
									# additional L_2 normalization over each hidden-state
									A__					:       Any     =F.normalize(lowercase__		,      dim=-1			)

									A__					:       List[Any]     =prompt_embeds

									# forward
									A__					:       Union[str, Any]     =audioldm_pipe(**lowercase__			)
									A__					:       Dict     =output.audios[0]

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


			def lowercase__						(				self	:						Union[str, Any]			)      ->		Optional[int]:





									'''simple docstring'''
									A__					:       int     =self.get_dummy_components()
									A__					:       Union[str, Any]     =AudioLDMPipeline(**lowercase__			)
									A__					:       Tuple     =audioldm_pipe.to(lowercase__			)
									A__					:       int     =audioldm_pipe.to(lowercase__			)
									audioldm_pipe.set_progress_bar_config(disable=lowercase__			)

									A__					:       Any     =self.get_dummy_inputs(lowercase__			)
									A__					:       Any     =3 * ["""this is a negative prompt"""]
									A__					:       Dict     =negative_prompt
									A__					:       int     =3 * [inputs["""prompt"""]]

									# forward
									A__					:       List[str]     =audioldm_pipe(**lowercase__			)
									A__					:       str     =output.audios[0]

									A__					:       Optional[Any]     =self.get_dummy_inputs(lowercase__			)
									A__					:       Tuple     =3 * [inputs.pop("""prompt"""			)]

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

															A__					:       Union[str, Any]     =audioldm_pipe.text_encoder(
															    lowercase__		,      )
															A__					:       Tuple     =text_embeds.text_embeds
															# additional L_2 normalization over each hidden-state
															A__					:       Optional[Any]     =F.normalize(lowercase__		,      dim=-1			)

															embeds.append(lowercase__			)

									A__   ,						A__					:       Dict     =embeds

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

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


			def lowercase__						(				self	:						Optional[Any]			)      ->		List[str]:





									'''simple docstring'''
									A__					:       List[str]     ="""cpu"""  # ensure determinism for the device-dependent torch.Generator
									A__					:       List[Any]     =self.get_dummy_components()
									A__					:       Dict     =PNDMScheduler(skip_prk_steps=lowercase__			)
									A__					:       int     =AudioLDMPipeline(**lowercase__			)
									A__					:       List[str]     =audioldm_pipe.to(lowercase__			)
									audioldm_pipe.set_progress_bar_config(disable=lowercase__			)

									A__					:       int     =self.get_dummy_inputs(lowercase__			)
									A__					:       Optional[int]     ="""egg cracking"""
									A__					:       Dict     =audioldm_pipe(**lowercase__		,      negative_prompt=lowercase__			)
									A__					:       Optional[int]     =output.audios[0]

									assert audio.ndim == 1
									assert len(lowercase__			) == 2_56

									A__					:       Any     =audio[:10]
									A__					:       str     =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 lowercase__						(				self	:						Optional[int]			)      ->		Optional[Any]:





									'''simple docstring'''
									A__					:       List[str]     ="""cpu"""  # ensure determinism for the device-dependent torch.Generator
									A__					:       Optional[Any]     =self.get_dummy_components()
									A__					:       Any     =PNDMScheduler(skip_prk_steps=lowercase__			)
									A__					:       Dict     =AudioLDMPipeline(**lowercase__			)
									A__					:       Any     =audioldm_pipe.to(lowercase__			)
									audioldm_pipe.set_progress_bar_config(disable=lowercase__			)

									A__					:       str     ="""A hammer hitting a wooden surface"""

									# test num_waveforms_per_prompt=1 (default)
									A__					:       Tuple     =audioldm_pipe(lowercase__		,      num_inference_steps=2			).audios

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

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

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

									# test num_waveforms_per_prompt for single prompt
									A__					:       List[str]     =2
									A__					:       Optional[int]     =audioldm_pipe(lowercase__		,      num_inference_steps=2		,      num_waveforms_per_prompt=lowercase__			).audios

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

									# test num_waveforms_per_prompt for batch of prompts
									A__					:       Tuple     =2
									A__					:       Optional[int]     =audioldm_pipe(
									    [prompt] * batch_size		,      num_inference_steps=2		,      num_waveforms_per_prompt=lowercase__			).audios

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


			def lowercase__						(				self	:						Dict			)      ->		str:





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

									A__					:       Any     =self.get_dummy_inputs(lowercase__			)
									A__					:       Dict     =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__					:       Union[str, Any]     =audioldm_pipe(audio_length_in_s=0.032		,      **lowercase__			)
									A__					:       Any     =output.audios[0]

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


			def lowercase__						(				self	:						str			)      ->		Any:





									'''simple docstring'''
									A__					:       int     =self.get_dummy_components()
									A__					:       int     =AudioLDMPipeline(**lowercase__			)
									A__					:       int     =audioldm_pipe.to(lowercase__			)
									audioldm_pipe.set_progress_bar_config(disable=lowercase__			)

									A__					:       Optional[Any]     =["""hey"""]

									A__					:       Any     =audioldm_pipe(lowercase__		,      num_inference_steps=1			)
									A__					:       int     =output.audios.shape
									assert audio_shape == (1, 2_56)

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


			def lowercase__						(				self	:						List[Any]			)      ->		Optional[int]:





									'''simple docstring'''
									self._test_attention_slicing_forward_pass(test_mean_pixel_difference=lowercase__			)


			def lowercase__						(				self	:						str			)      ->		str:





									'''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 lowercase__						(				self	:						List[str]			)      ->		List[str]:





									'''simple docstring'''
									self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=lowercase__			)



@slow
class lowerCamelCase			(  unittest.TestCase						):



			'''simple docstring'''






			def lowercase__						(				self	:						Dict			)      ->		Optional[int]:





									'''simple docstring'''
									super().tearDown()
									gc.collect()
									torch.cuda.empty_cache()


			def lowercase__						(				self	:						Any		,      lowerCAmelCase_	:						str		,      lowerCAmelCase_	:						Dict="cpu"		,      lowerCAmelCase_	:						List[Any]=torch.floataa		,      lowerCAmelCase_	:						Tuple=0			)      ->		List[str]:





									'''simple docstring'''
									A__					:       Tuple     =torch.Generator(device=lowercase__			).manual_seed(lowercase__			)
									A__					:       List[str]     =np.random.RandomState(lowercase__			).standard_normal((1, 8, 1_28, 16)			)
									A__					:       Any     =torch.from_numpy(lowercase__			).to(device=lowercase__		,      dtype=lowercase__			)
									A__					:       int     ={
									    """prompt""": """A hammer hitting a wooden surface""",
									    """latents""": latents,
									    """generator""": generator,
									    """num_inference_steps""": 3,
									    """guidance_scale""": 2.5,
									}
									return inputs


			def lowercase__						(				self	:						List[str]			)      ->		Tuple:





									'''simple docstring'''
									A__					:       Optional[int]     =AudioLDMPipeline.from_pretrained("""cvssp/audioldm"""			)
									A__					:       Tuple     =audioldm_pipe.to(lowercase__			)
									audioldm_pipe.set_progress_bar_config(disable=lowercase__			)

									A__					:       Dict     =self.get_inputs(lowercase__			)
									A__					:       Any     =25
									A__					:       Tuple     =audioldm_pipe(**lowercase__			).audios[0]

									assert audio.ndim == 1
									assert len(lowercase__			) == 8_19_20

									A__					:       Any     =audio[7_72_30:7_72_40]
									A__					:       List[Any]     =np.array(
									    [-0.4884, -0.4607, 0.0023, 0.5007, 0.5896, 0.5151, 0.3813, -0.0208, -0.3687, -0.4315]			)
									A__					:       Union[str, Any]     =np.abs(expected_slice - audio_slice			).max()
									assert max_diff < 1e-2



			def lowercase__						(				self	:						Dict			)      ->		List[str]:





									'''simple docstring'''
									A__					:       Tuple     =AudioLDMPipeline.from_pretrained("""cvssp/audioldm"""			)
									A__					:       List[str]     =LMSDiscreteScheduler.from_config(audioldm_pipe.scheduler.config			)
									A__					:       Dict     =audioldm_pipe.to(lowercase__			)
									audioldm_pipe.set_progress_bar_config(disable=lowercase__			)

									A__					:       Tuple     =self.get_inputs(lowercase__			)
									A__					:       Dict     =audioldm_pipe(**lowercase__			).audios[0]

									assert audio.ndim == 1
									assert len(lowercase__			) == 8_19_20

									A__					:       Optional[int]     =audio[2_77_80:2_77_90]
									A__					:       Tuple     =np.array([-0.2131, -0.0873, -0.0124, -0.0189, 0.0569, 0.1373, 0.1883, 0.2886, 0.3297, 0.2212]			)
									A__					:       Tuple     =np.abs(expected_slice - audio_slice			).max()
									assert max_diff < 3e-2




'''simple docstring'''



def 						__lowerCamelCase	(       __snake_case					:		int	)	->							bool:






						"""simple docstring"""





						if p < 2:
												raise ValueError("""p should not be less than 2!"""	)
						elif p == 2:
												return True

						A__					:       Any     =4
						A__					:       int     =(1 << p) - 1
						for _ in range(p - 2	):
												A__					:       Dict     =((s * s) - 2) % m
						return s == 0


if __name__ == "__main__":
		print(lucas_lehmer_test(7))
		print(lucas_lehmer_test(11))

