



'''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       __magic_name__		(       _UpperCamelCase     ,		unittest.TestCase  ):
							lowerCAmelCase			:       Any  							=   AudioLDMPipeline
							lowerCAmelCase			:       Dict  							=   TEXT_TO_AUDIO_PARAMS
							lowerCAmelCase			:       str  							=   TEXT_TO_AUDIO_BATCH_PARAMS
							lowerCAmelCase			:       Union[str, Any]  							=   frozenset(
							    [
							        'num_inference_steps',
							        'num_waveforms_per_prompt',
							        'generator',
							        'latents',
							        'output_type',
							        'return_dict',
							        'callback',
							        'callback_steps',
							    ]  )







							def 				__lowercase     (				self   :			Any						):
									torch.manual_seed(0						)
									_a	: Dict								=				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      ,)
									_a	: List[str]								=				DDIMScheduler(
									    beta_start=0.0_00_85      ,beta_end=0.0_12      ,beta_schedule='scaled_linear'      ,clip_sample=_UpperCAmelCase      ,set_alpha_to_one=_UpperCAmelCase      ,)
									torch.manual_seed(0						)
									_a	: Dict								=				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	: Optional[Any]								=				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	: Optional[int]								=				ClapTextModelWithProjection(_UpperCAmelCase						)
									_a	: Optional[int]								=				RobertaTokenizer.from_pretrained('hf-internal-testing/tiny-random-roberta'      ,model_max_length=77						)

									_a	: Union[str, Any]								=				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=_UpperCAmelCase      ,)

									_a	: Union[str, Any]								=				SpeechTaHifiGan(_UpperCAmelCase						)

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







							def 				__lowercase     (				self   :			Dict      ,_UpperCAmelCase   :			str      ,_UpperCAmelCase   :			Optional[int]=0						):
									if str(_UpperCAmelCase						).startswith('mps'						):
											_a	: Tuple								=				torch.manual_seed(_UpperCAmelCase						)
									else:
											_a	: Tuple								=				torch.Generator(device=_UpperCAmelCase						).manual_seed(_UpperCAmelCase						)
									_a	: List[str]								=				{
									    'prompt': 'A hammer hitting a wooden surface',
									    'generator': generator,
									    'num_inference_steps': 2,
									    'guidance_scale': 6.0,
									}
									return inputs







							def 				__lowercase     (				self   :			Dict						):
									_a	: int								=				'cpu'  # ensure determinism for the device-dependent torch.Generator

									_a	: Union[str, Any]								=				self.get_dummy_components()
									_a	: Any								=				AudioLDMPipeline(**_UpperCAmelCase						)
									_a	: str								=				audioldm_pipe.to(_UpperCAmelCase						)
									audioldm_pipe.set_progress_bar_config(disable=_UpperCAmelCase						)

									_a	: Dict								=				self.get_dummy_inputs(_UpperCAmelCase						)
									_a	: Dict								=				audioldm_pipe(**_UpperCAmelCase						)
									_a	: Any								=				output.audios[0]

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

									_a	: int								=				audio[:10]
									_a	: Optional[Any]								=				np.array(
									    [-0.00_50, 0.00_50, -0.00_60, 0.00_33, -0.00_26, 0.00_33, -0.00_27, 0.00_33, -0.00_28, 0.00_33]						)

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







							def 				__lowercase     (				self   :			List[Any]						):
									_a	: List[str]								=				self.get_dummy_components()
									_a	: List[str]								=				AudioLDMPipeline(**_UpperCAmelCase						)
									_a	: Union[str, Any]								=				audioldm_pipe.to(_UpperCAmelCase						)
									_a	: str								=				audioldm_pipe.to(_UpperCAmelCase						)
									audioldm_pipe.set_progress_bar_config(disable=_UpperCAmelCase						)

									_a	: int								=				self.get_dummy_inputs(_UpperCAmelCase						)
									_a	: str								=				3 * [inputs['prompt']]

									# forward
									_a	: Any								=				audioldm_pipe(**_UpperCAmelCase						)
									_a	: List[Any]								=				output.audios[0]

									_a	: int								=				self.get_dummy_inputs(_UpperCAmelCase						)
									_a	: int								=				3 * [inputs.pop('prompt'						)]

									_a	: List[Any]								=				audioldm_pipe.tokenizer(
									    _UpperCAmelCase      ,padding='max_length'      ,max_length=audioldm_pipe.tokenizer.model_max_length      ,truncation=_UpperCAmelCase      ,return_tensors='pt'      ,)
									_a	: List[Any]								=				text_inputs['input_ids'].to(_UpperCAmelCase						)

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

									_a	: int								=				prompt_embeds

									# forward
									_a	: Any								=				audioldm_pipe(**_UpperCAmelCase						)
									_a	: List[str]								=				output.audios[0]

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







							def 				__lowercase     (				self   :			Tuple						):
									_a	: Dict								=				self.get_dummy_components()
									_a	: int								=				AudioLDMPipeline(**_UpperCAmelCase						)
									_a	: str								=				audioldm_pipe.to(_UpperCAmelCase						)
									_a	: List[str]								=				audioldm_pipe.to(_UpperCAmelCase						)
									audioldm_pipe.set_progress_bar_config(disable=_UpperCAmelCase						)

									_a	: Any								=				self.get_dummy_inputs(_UpperCAmelCase						)
									_a	: Optional[int]								=				3 * ['this is a negative prompt']
									_a	: Optional[int]								=				negative_prompt
									_a	: Optional[Any]								=				3 * [inputs['prompt']]

									# forward
									_a	: List[Any]								=				audioldm_pipe(**_UpperCAmelCase						)
									_a	: str								=				output.audios[0]

									_a	: Optional[int]								=				self.get_dummy_inputs(_UpperCAmelCase						)
									_a	: List[str]								=				3 * [inputs.pop('prompt'						)]

									_a	: int								=				[]
									for p in [prompt, negative_prompt]:
											_a	: Optional[Any]								=				audioldm_pipe.tokenizer(
											    _UpperCAmelCase      ,padding='max_length'      ,max_length=audioldm_pipe.tokenizer.model_max_length      ,truncation=_UpperCAmelCase      ,return_tensors='pt'      ,)
											_a	: Optional[Any]								=				text_inputs['input_ids'].to(_UpperCAmelCase						)

											_a	: Any								=				audioldm_pipe.text_encoder(
											    _UpperCAmelCase      ,)
											_a	: Dict								=				text_embeds.text_embeds
											# additional L_2 normalization over each hidden-state
											_a	: Optional[Any]								=				F.normalize(_UpperCAmelCase      ,dim=-1						)

											embeds.append(_UpperCAmelCase						)

									_a			,   _a	: Tuple								=				embeds

									# forward
									_a	: List[Any]								=				audioldm_pipe(**_UpperCAmelCase						)
									_a	: Tuple								=				output.audios[0]

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







							def 				__lowercase     (				self   :			str						):
									_a	: int								=				'cpu'  # ensure determinism for the device-dependent torch.Generator
									_a	: Optional[int]								=				self.get_dummy_components()
									_a	: Any								=				PNDMScheduler(skip_prk_steps=_UpperCAmelCase						)
									_a	: Optional[int]								=				AudioLDMPipeline(**_UpperCAmelCase						)
									_a	: List[Any]								=				audioldm_pipe.to(_UpperCAmelCase						)
									audioldm_pipe.set_progress_bar_config(disable=_UpperCAmelCase						)

									_a	: Any								=				self.get_dummy_inputs(_UpperCAmelCase						)
									_a	: Dict								=				'egg cracking'
									_a	: Dict								=				audioldm_pipe(**_UpperCAmelCase      ,negative_prompt=_UpperCAmelCase						)
									_a	: Union[str, Any]								=				output.audios[0]

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

									_a	: Optional[int]								=				audio[:10]
									_a	: Optional[int]								=				np.array(
									    [-0.00_51, 0.00_50, -0.00_60, 0.00_34, -0.00_26, 0.00_33, -0.00_27, 0.00_33, -0.00_28, 0.00_32]						)

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







							def 				__lowercase     (				self   :			Tuple						):
									_a	: Dict								=				'cpu'  # ensure determinism for the device-dependent torch.Generator
									_a	: Dict								=				self.get_dummy_components()
									_a	: int								=				PNDMScheduler(skip_prk_steps=_UpperCAmelCase						)
									_a	: Any								=				AudioLDMPipeline(**_UpperCAmelCase						)
									_a	: Dict								=				audioldm_pipe.to(_UpperCAmelCase						)
									audioldm_pipe.set_progress_bar_config(disable=_UpperCAmelCase						)

									_a	: Optional[Any]								=				'A hammer hitting a wooden surface'

									# test num_waveforms_per_prompt=1 (default)
									_a	: Dict								=				audioldm_pipe(_UpperCAmelCase      ,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	: List[str]								=				2
									_a	: Dict								=				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
									_a	: Dict								=				2
									_a	: Optional[int]								=				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 				__lowercase     (				self   :			Optional[Any]						):
									_a	: Dict								=				'cpu'  # ensure determinism for the device-dependent torch.Generator
									_a	: int								=				self.get_dummy_components()
									_a	: Tuple								=				AudioLDMPipeline(**_UpperCAmelCase						)
									_a	: Optional[int]								=				audioldm_pipe.to(_UpperCAmelCase						)
									audioldm_pipe.set_progress_bar_config(disable=_UpperCAmelCase						)
									_a	: List[Any]								=				audioldm_pipe.vocoder.config.sampling_rate

									_a	: List[Any]								=				self.get_dummy_inputs(_UpperCAmelCase						)
									_a	: int								=				audioldm_pipe(audio_length_in_s=0.0_16      ,**_UpperCAmelCase						)
									_a	: Any								=				output.audios[0]

									assert audio.ndim == 1
									assert len(_UpperCAmelCase						) / vocoder_sampling_rate == 0.0_16

									_a	: int								=				audioldm_pipe(audio_length_in_s=0.0_32      ,**_UpperCAmelCase						)
									_a	: Tuple								=				output.audios[0]

									assert audio.ndim == 1
									assert len(_UpperCAmelCase						) / vocoder_sampling_rate == 0.0_32







							def 				__lowercase     (				self   :			Optional[Any]						):
									_a	: Union[str, Any]								=				self.get_dummy_components()
									_a	: Dict								=				AudioLDMPipeline(**_UpperCAmelCase						)
									_a	: Optional[Any]								=				audioldm_pipe.to(_UpperCAmelCase						)
									audioldm_pipe.set_progress_bar_config(disable=_UpperCAmelCase						)

									_a	: List[Any]								=				['hey']

									_a	: Any								=				audioldm_pipe(_UpperCAmelCase      ,num_inference_steps=1						)
									_a	: Optional[int]								=				output.audios.shape
									assert audio_shape == (1, 256)

									_a	: Tuple								=				audioldm_pipe.vocoder.config
									config.model_in_dim *= 2
									_a	: int								=				SpeechTaHifiGan(_UpperCAmelCase						).to(_UpperCAmelCase						)
									_a	: Tuple								=				audioldm_pipe(_UpperCAmelCase      ,num_inference_steps=1						)
									_a	: List[str]								=				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 				__lowercase     (				self   :			Dict						):
									self._test_attention_slicing_forward_pass(test_mean_pixel_difference=_UpperCAmelCase						)







							def 				__lowercase     (				self   :			Any						):
									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 				__lowercase     (				self   :			Any						):
									self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=_UpperCAmelCase						)

@slow
class       __magic_name__		(       unittest.TestCase  ):







							def 				__lowercase     (				self   :			Tuple						):
									super().tearDown()
									gc.collect()
									torch.cuda.empty_cache()







							def 				__lowercase     (				self   :			Dict      ,_UpperCAmelCase   :			str      ,_UpperCAmelCase   :			List[str]="cpu"      ,_UpperCAmelCase   :			Optional[Any]=torch.floataa      ,_UpperCAmelCase   :			Optional[Any]=0						):
									_a	: Union[str, Any]								=				torch.Generator(device=_UpperCAmelCase						).manual_seed(_UpperCAmelCase						)
									_a	: str								=				np.random.RandomState(_UpperCAmelCase						).standard_normal((1, 8, 128, 16)						)
									_a	: List[str]								=				torch.from_numpy(_UpperCAmelCase						).to(device=_UpperCAmelCase      ,dtype=_UpperCAmelCase						)
									_a	: Optional[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   :			str						):
									_a	: int								=				AudioLDMPipeline.from_pretrained('cvssp/audioldm'						)
									_a	: Any								=				audioldm_pipe.to(_UpperCAmelCase						)
									audioldm_pipe.set_progress_bar_config(disable=_UpperCAmelCase						)

									_a	: List[str]								=				self.get_inputs(_UpperCAmelCase						)
									_a	: int								=				25
									_a	: Any								=				audioldm_pipe(**_UpperCAmelCase						).audios[0]

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

									_a	: Optional[int]								=				audio[77230:77240]
									_a	: int								=				np.array(
									    [-0.48_84, -0.46_07, 0.00_23, 0.50_07, 0.58_96, 0.51_51, 0.38_13, -0.02_08, -0.36_87, -0.43_15]						)
									_a	: Tuple								=				np.abs(expected_slice - audio_slice						).max()
									assert max_diff < 1E-2







							def 				__lowercase     (				self   :			int						):
									_a	: str								=				AudioLDMPipeline.from_pretrained('cvssp/audioldm'						)
									_a	: Optional[Any]								=				LMSDiscreteScheduler.from_config(audioldm_pipe.scheduler.config						)
									_a	: str								=				audioldm_pipe.to(_UpperCAmelCase						)
									audioldm_pipe.set_progress_bar_config(disable=_UpperCAmelCase						)

									_a	: List[Any]								=				self.get_inputs(_UpperCAmelCase						)
									_a	: List[Any]								=				audioldm_pipe(**_UpperCAmelCase						).audios[0]

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

									_a	: Union[str, Any]								=				audio[27780:27790]
									_a	: List[Any]								=				np.array([-0.21_31, -0.08_73, -0.01_24, -0.01_89, 0.05_69, 0.13_73, 0.18_83, 0.28_86, 0.32_97, 0.22_12]						)
									_a	: Any								=				np.abs(expected_slice - audio_slice						).max()
									assert max_diff < 3E-2









'''simple docstring'''

def 	__lowerCamelCase	( )     -> Union[str, Any]:
		_a	: Optional[Any]								=				[]
		_a	: List[str]								=				1

		while len(lowerCAmelCase_    ) < 1E6:
				constant.append(str(lowerCAmelCase_    )    )
				i += 1

		_a	: Optional[Any]								=				''.join(lowerCAmelCase_    )

		return (
		    int(constant[0]    )
		    * int(constant[9]    )
		    * int(constant[99]    )
		    * int(constant[999]    )
		    * int(constant[9999]    )
		    * int(constant[99999]    )
		    * int(constant[999999]    )
		)


if __name__ == "__main__":
							print(solution())




