


"""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     (snake_case__						,		unittest.TestCase):





							'''simple docstring'''

							__lowercase:		Optional[int]							      =    AudioLDMPipeline
							__lowercase:		Optional[Any]							      =    TEXT_TO_AUDIO_PARAMS
							__lowercase:		List[str]							      =    TEXT_TO_AUDIO_BATCH_PARAMS
							__lowercase:		Optional[Any]							      =    frozenset(
							    [
							        """num_inference_steps""",
							        """num_waveforms_per_prompt""",
							        """generator""",
							        """latents""",
							        """output_type""",
							        """return_dict""",
							        """callback""",
							        """callback_steps""",
							    ])



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



														"""simple docstring"""



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

														snake_case_           =		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=UpperCAmelCase_		,       )

														snake_case_           =		SpeechTaHifiGan(UpperCAmelCase_       )

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



							def 		lowerCAmelCase       (				self							:      Optional[Any]		,       UpperCAmelCase_							:      Union[str, Any]		,       UpperCAmelCase_							:      int=0       )					->Tuple:



														"""simple docstring"""



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



							def 		lowerCAmelCase       (				self							:      Tuple       )					->Dict:



														"""simple docstring"""



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

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

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

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

														snake_case_           =		audio[:10]
														snake_case_           =		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 		lowerCAmelCase       (				self							:      str       )					->List[str]:



														"""simple docstring"""



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

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

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

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

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

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

														snake_case_           =		prompt_embeds

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

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



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



														"""simple docstring"""



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

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

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

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

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

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

																					embeds.append(UpperCAmelCase_       )

														snake_case_       ,						snake_case_           =		embeds

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

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



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



														"""simple docstring"""



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

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

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

														snake_case_           =		audio[:10]
														snake_case_           =		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 		lowerCAmelCase       (				self							:      Tuple       )					->Optional[int]:



														"""simple docstring"""



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

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

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

														assert audios.shape == (1, 256)

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

														assert audios.shape == (batch_size, 256)

														# test num_waveforms_per_prompt for single prompt
														snake_case_           =		2
														snake_case_           =		audioldm_pipe(UpperCAmelCase_		,       num_inference_steps=2		,       num_waveforms_per_prompt=UpperCAmelCase_       ).audios

														assert audios.shape == (num_waveforms_per_prompt, 256)

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

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



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



														"""simple docstring"""



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

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

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

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

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



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



														"""simple docstring"""



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

														snake_case_           =		["""hey"""]

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

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



														"""simple docstring"""



														self._test_attention_slicing_forward_pass(test_mean_pixel_difference=UpperCAmelCase_       )



							def 		lowerCAmelCase       (				self							:      Dict       )					->List[Any]:



														"""simple docstring"""



														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 		lowerCAmelCase       (				self							:      Union[str, Any]       )					->Dict:



														"""simple docstring"""



														self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=UpperCAmelCase_       )





@slow
class      __A     (unittest.TestCase):





							'''simple docstring'''

							def 		lowerCAmelCase       (				self							:      Optional[int]       )					->int:



														"""simple docstring"""



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



							def 		lowerCAmelCase       (				self							:      Optional[int]		,       UpperCAmelCase_							:      Tuple		,       UpperCAmelCase_							:      int="cpu"		,       UpperCAmelCase_							:      Any=torch.floataa		,       UpperCAmelCase_							:      Dict=0       )					->List[str]:



														"""simple docstring"""



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



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



														"""simple docstring"""



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

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

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

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



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



														"""simple docstring"""



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

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

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

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







"""simple docstring"""
from math import factorial







def 						_a				(      _SCREAMING_SNAKE_CASE = 20				)    ->				int:
							snake_case_           =		2 * n  # middle entry of odd rows starting at row 3 is the solution for n = 1,
							# 2, 3,...
							snake_case_           =		n // 2

							return int(factorial(_SCREAMING_SNAKE_CASE				) / (factorial(_SCREAMING_SNAKE_CASE				) * factorial(n - k				))				)


if __name__ == "__main__":
				import sys

				if len(sys.argv) == 1:
								print(solution(20))
				else:
								try:
												__SCREAMING_SNAKE_CASE							:    Optional[int]		=    int(sys.argv[1])
												print(solution(n))
								except ValueError:
												print('Invalid entry - please enter a number.')



