

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				(					SCREAMING_SNAKE_CASE  ,						unittest.TestCase			):
	_lowercase  :   List[str]       				=  AudioLDMPipeline
	_lowercase  :   Dict       				=  TEXT_TO_AUDIO_PARAMS
	_lowercase  :   Optional[int]       				=  TEXT_TO_AUDIO_BATCH_PARAMS
	_lowercase  :   Dict       				=  frozenset(
	    [
	        "num_inference_steps",
	        "num_waveforms_per_prompt",
	        "generator",
	        "latents",
	        "output_type",
	        "return_dict",
	        "callback",
	        "callback_steps",
	    ]			)







	def 	_SCREAMING_SNAKE_CASE							(   self: List[Any]      ):

						'''simple docstring'''





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

						__magic_name__							=    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=__A  , )

						__magic_name__							=    SpeechTaHifiGan(__A      )

						__magic_name__							=    {
						    'unet': unet,
						    'scheduler': scheduler,
						    'vae': vae,
						    'text_encoder': text_encoder,
						    'tokenizer': tokenizer,
						    'vocoder': vocoder,
						}
						return components







	def 	_SCREAMING_SNAKE_CASE							(   self: Optional[int]  , __UpperCamelCase: List[str]  , __UpperCamelCase: List[str]=0      ):

						'''simple docstring'''





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







	def 	_SCREAMING_SNAKE_CASE							(   self: int      ):

						'''simple docstring'''





						__magic_name__							=    'cpu'  # ensure determinism for the device-dependent torch.Generator

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

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

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

						__magic_name__							=    audio[:10]
						__magic_name__							=    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 	_SCREAMING_SNAKE_CASE							(   self: Optional[Any]      ):

						'''simple docstring'''





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

						__magic_name__							=    self.get_dummy_inputs(__A      )
						__magic_name__							=    3 * [inputs['prompt']]

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

						__magic_name__							=    self.get_dummy_inputs(__A      )
						__magic_name__							=    3 * [inputs.pop('prompt'      )]

						__magic_name__							=    audioldm_pipe.tokenizer(
						    __A  , padding='max_length'  , max_length=audioldm_pipe.tokenizer.model_max_length  , truncation=__A  , return_tensors='pt'  , )
						__magic_name__							=    text_inputs['input_ids'].to(__A      )

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

						__magic_name__							=    prompt_embeds

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

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







	def 	_SCREAMING_SNAKE_CASE							(   self: Union[str, Any]      ):

						'''simple docstring'''





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

						__magic_name__							=    self.get_dummy_inputs(__A      )
						__magic_name__							=    3 * ['this is a negative prompt']
						__magic_name__							=    negative_prompt
						__magic_name__							=    3 * [inputs['prompt']]

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

						__magic_name__							=    self.get_dummy_inputs(__A      )
						__magic_name__							=    3 * [inputs.pop('prompt'      )]

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

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

											embeds.append(__A      )

						__magic_name__,	__magic_name__							=    embeds

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

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







	def 	_SCREAMING_SNAKE_CASE							(   self: int      ):

						'''simple docstring'''





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

						__magic_name__							=    self.get_dummy_inputs(__A      )
						__magic_name__							=    'egg cracking'
						__magic_name__							=    audioldm_pipe(**__A  , negative_prompt=__A      )
						__magic_name__							=    output.audios[0]

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

						__magic_name__							=    audio[:10]
						__magic_name__							=    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 	_SCREAMING_SNAKE_CASE							(   self: Optional[Any]      ):

						'''simple docstring'''





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

						__magic_name__							=    'A hammer hitting a wooden surface'

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

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

						# test num_waveforms_per_prompt=1 (default) for batch of prompts
						__magic_name__							=    2
						__magic_name__							=    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
						__magic_name__							=    2
						__magic_name__							=    audioldm_pipe(__A  , num_inference_steps=2  , num_waveforms_per_prompt=__A      ).audios

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

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

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







	def 	_SCREAMING_SNAKE_CASE							(   self: Union[str, Any]      ):

						'''simple docstring'''





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

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

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

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

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







	def 	_SCREAMING_SNAKE_CASE							(   self: str      ):

						'''simple docstring'''





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

						__magic_name__							=    ['hey']

						__magic_name__							=    audioldm_pipe(__A  , num_inference_steps=1      )
						__magic_name__							=    output.audios.shape
						assert audio_shape == (1, 2_56)

						__magic_name__							=    audioldm_pipe.vocoder.config
						config.model_in_dim *= 2
						__magic_name__							=    SpeechTaHifiGan(__A      ).to(__A      )
						__magic_name__							=    audioldm_pipe(__A  , num_inference_steps=1      )
						__magic_name__							=    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 	_SCREAMING_SNAKE_CASE							(   self: Union[str, Any]      ):

						'''simple docstring'''





						self._test_attention_slicing_forward_pass(test_mean_pixel_difference=__A      )







	def 	_SCREAMING_SNAKE_CASE							(   self: int      ):

						'''simple docstring'''





						self._test_inference_batch_single_identical(test_mean_pixel_difference=__A      )







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

						'''simple docstring'''





						self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=__A      )




@slow
class 				__UpperCamelCase				(					unittest.TestCase			):







	def 	_SCREAMING_SNAKE_CASE							(   self: List[str]      ):

						'''simple docstring'''





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







	def 	_SCREAMING_SNAKE_CASE							(   self: int  , __UpperCamelCase: Optional[Any]  , __UpperCamelCase: str="cpu"  , __UpperCamelCase: Dict=torch.floataa  , __UpperCamelCase: Union[str, Any]=0      ):

						'''simple docstring'''





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







	def 	_SCREAMING_SNAKE_CASE							(   self: Any      ):

						'''simple docstring'''





						__magic_name__							=    AudioLDMPipeline.from_pretrained('cvssp/audioldm'      )
						__magic_name__							=    audioldm_pipe.to(__A      )
						audioldm_pipe.set_progress_bar_config(disable=__A      )

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

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

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







	def 	_SCREAMING_SNAKE_CASE							(   self: Optional[Any]      ):

						'''simple docstring'''





						__magic_name__							=    AudioLDMPipeline.from_pretrained('cvssp/audioldm'      )
						__magic_name__							=    LMSDiscreteScheduler.from_config(audioldm_pipe.scheduler.config      )
						__magic_name__							=    audioldm_pipe.to(__A      )
						audioldm_pipe.set_progress_bar_config(disable=__A      )

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

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

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







import os
import unittest

from transformers import LayoutLMTokenizer, LayoutLMTokenizerFast
from transformers.models.layoutlm.tokenization_layoutlm import VOCAB_FILES_NAMES
from transformers.testing_utils import require_tokenizers

from ...test_tokenization_common import TokenizerTesterMixin

@require_tokenizers
class 				__UpperCamelCase				(					SCREAMING_SNAKE_CASE  ,						unittest.TestCase			):
	_lowercase  :   Tuple       				=  LayoutLMTokenizer
	_lowercase  :   List[str]       				=  LayoutLMTokenizerFast
	_lowercase  :   List[Any]       				=  True
	_lowercase  :   Optional[int]       				=  True







	def 	_SCREAMING_SNAKE_CASE							(   self: Any      ):

						'''simple docstring'''





						super().setUp()

						__magic_name__							=    [
						    '[UNK]',
						    '[CLS]',
						    '[SEP]',
						    'want',
						    '##want',
						    '##ed',
						    'wa',
						    'un',
						    'runn',
						    '##ing',
						    ',',
						    'low',
						    'lowest',
						]
						__magic_name__							=    os.path.join(self.tmpdirname  , VOCAB_FILES_NAMES['vocab_file']      )
						with open(self.vocab_file  , 'w'  , encoding='utf-8'      ) as vocab_writer:
											vocab_writer.write(''.join([x + '\n' for x in vocab_tokens]      )      )







	def 	_SCREAMING_SNAKE_CASE							(   self: Union[str, Any]  , **__UpperCamelCase: Union[str, Any]      ):

						'''simple docstring'''





						return LayoutLMTokenizer.from_pretrained(self.tmpdirname  , **__UpperCamelCase      )







	def 	_SCREAMING_SNAKE_CASE							(   self: Tuple  , __UpperCamelCase: List[str]      ):

						'''simple docstring'''





						__magic_name__							=    'UNwant\u00E9d,running'
						__magic_name__							=    'unwanted, running'
						return input_text, output_text







	def 	_SCREAMING_SNAKE_CASE							(   self: List[Any]      ):

						'''simple docstring'''





						__magic_name__							=    self.tokenizer_class(self.vocab_file      )

						__magic_name__							=    tokenizer.tokenize('UNwant\u00E9d,running'      )
						self.assertListEqual(__UpperCamelCase  , ['un', '##want', '##ed', ',', 'runn', '##ing']      )
						self.assertListEqual(tokenizer.convert_tokens_to_ids(__UpperCamelCase      )  , [7, 4, 5, 10, 8, 9]      )







	def 	_SCREAMING_SNAKE_CASE							(   self: Dict      ):

						'''simple docstring'''





						pass




