






"""simple docstring"""






import math
from collections.abc import Callable





def 							UpperCAmelCase		(		snake_case			:					Callable[[float], float]      ,       snake_case			:					float      ,       snake_case			:					float    ):
					_lowerCAmelCase:float									=  xa
					_lowerCAmelCase:float									=  xa
					while True:
										if x_n == x_na or function(snake_case    ) == function(snake_case    ):
															raise ZeroDivisionError('''float division by zero, could not find root'''    )
										_lowerCAmelCase:float									=  x_na - (
										    function(snake_case    ) / ((function(snake_case    ) - function(snake_case    )) / (x_na - x_n))
										)
										if abs(x_na - x_na    ) < 10**-5:
															return x_na
										_lowerCAmelCase:List[str]									=  x_na
										_lowerCAmelCase:Optional[Any]									=  x_na





def 							UpperCAmelCase		(		snake_case			:					float    ):
					return math.pow(snake_case      ,       3    ) - (2 * x) - 5


if __name__ == "__main__":
				print(intersection(f, 3, 3.5))












"""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__			(       UpperCamelCase_					,	unittest.TestCase  ):
						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       __UpperCamelCase     (							self      :	int)						->       Any:




											"""simple docstring"""







											torch.manual_seed(0)
											_lowerCAmelCase: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=a__     ,)
											_lowerCAmelCase:Optional[int]									=  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)
											_lowerCAmelCase:Optional[Any]									=  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)
											_lowerCAmelCase:Dict									=  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     ,)
											_lowerCAmelCase:str									=  ClapTextModelWithProjection(a__)
											_lowerCAmelCase:Dict									=  RobertaTokenizer.from_pretrained('''hf-internal-testing/tiny-random-roberta'''     ,model_max_length=77)

											_lowerCAmelCase:Union[str, Any]									=  SpeechTaHifiGanConfig(
											    model_in_dim=8     ,sampling_rate=1_6000     ,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__     ,)

											_lowerCAmelCase:List[Any]									=  SpeechTaHifiGan(a__)

											_lowerCAmelCase:Optional[Any]									=  {
											    '''unet''': unet,
											    '''scheduler''': scheduler,
											    '''vae''': vae,
											    '''text_encoder''': text_encoder,
											    '''tokenizer''': tokenizer,
											    '''vocoder''': vocoder,
											}
											return components





						def       __UpperCamelCase     (							self      :	List[Any]     ,a__      :	int     ,a__      :	Tuple=0)						->       Optional[int]:




											"""simple docstring"""







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





						def       __UpperCamelCase     (							self      :	Optional[Any])						->       Any:




											"""simple docstring"""







											_lowerCAmelCase:str									=  '''cpu'''  # ensure determinism for the device-dependent torch.Generator

											_lowerCAmelCase:Dict									=  self.get_dummy_components()
											_lowerCAmelCase:List[str]									=  AudioLDMPipeline(**a__)
											_lowerCAmelCase:Optional[int]									=  audioldm_pipe.to(a__)
											audioldm_pipe.set_progress_bar_config(disable=a__)

											_lowerCAmelCase:str									=  self.get_dummy_inputs(a__)
											_lowerCAmelCase:Optional[Any]									=  audioldm_pipe(**a__)
											_lowerCAmelCase:List[str]									=  output.audios[0]

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

											_lowerCAmelCase:List[str]									=  audio[:10]
											_lowerCAmelCase:Dict									=  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       __UpperCamelCase     (							self      :	Tuple)						->       Tuple:




											"""simple docstring"""







											_lowerCAmelCase:int									=  self.get_dummy_components()
											_lowerCAmelCase:Optional[Any]									=  AudioLDMPipeline(**a__)
											_lowerCAmelCase:Union[str, Any]									=  audioldm_pipe.to(a__)
											_lowerCAmelCase:Any									=  audioldm_pipe.to(a__)
											audioldm_pipe.set_progress_bar_config(disable=a__)

											_lowerCAmelCase:Dict									=  self.get_dummy_inputs(a__)
											_lowerCAmelCase:List[Any]									=  3 * [inputs['''prompt''']]

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

											_lowerCAmelCase:Tuple									=  self.get_dummy_inputs(a__)
											_lowerCAmelCase:Optional[Any]									=  3 * [inputs.pop('''prompt''')]

											_lowerCAmelCase:Tuple									=  audioldm_pipe.tokenizer(
											    a__     ,padding='''max_length'''     ,max_length=audioldm_pipe.tokenizer.model_max_length     ,truncation=a__     ,return_tensors='''pt'''     ,)
											_lowerCAmelCase:Optional[int]									=  text_inputs['''input_ids'''].to(a__)

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

											_lowerCAmelCase:int									=  prompt_embeds

											# forward
											_lowerCAmelCase:Tuple									=  audioldm_pipe(**a__)
											_lowerCAmelCase:Dict									=  output.audios[0]

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





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




											"""simple docstring"""







											_lowerCAmelCase:Any									=  self.get_dummy_components()
											_lowerCAmelCase:str									=  AudioLDMPipeline(**a__)
											_lowerCAmelCase:int									=  audioldm_pipe.to(a__)
											_lowerCAmelCase:Any									=  audioldm_pipe.to(a__)
											audioldm_pipe.set_progress_bar_config(disable=a__)

											_lowerCAmelCase:Any									=  self.get_dummy_inputs(a__)
											_lowerCAmelCase:Tuple									=  3 * ['''this is a negative prompt''']
											_lowerCAmelCase:str									=  negative_prompt
											_lowerCAmelCase:List[Any]									=  3 * [inputs['''prompt''']]

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

											_lowerCAmelCase:Tuple									=  self.get_dummy_inputs(a__)
											_lowerCAmelCase:Tuple									=  3 * [inputs.pop('''prompt''')]

											_lowerCAmelCase:Tuple									=  []
											for p in [prompt, negative_prompt]:
																_lowerCAmelCase:str									=  audioldm_pipe.tokenizer(
																    a__     ,padding='''max_length'''     ,max_length=audioldm_pipe.tokenizer.model_max_length     ,truncation=a__     ,return_tensors='''pt'''     ,)
																_lowerCAmelCase:Dict									=  text_inputs['''input_ids'''].to(a__)

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

																embeds.append(a__)

											_lowerCAmelCase							,   _lowerCAmelCase:Optional[Any]									=  embeds

											# forward
											_lowerCAmelCase:List[str]									=  audioldm_pipe(**a__)
											_lowerCAmelCase:int									=  output.audios[0]

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





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




											"""simple docstring"""







											_lowerCAmelCase:Tuple									=  '''cpu'''  # ensure determinism for the device-dependent torch.Generator
											_lowerCAmelCase:Union[str, Any]									=  self.get_dummy_components()
											_lowerCAmelCase:Union[str, Any]									=  PNDMScheduler(skip_prk_steps=a__)
											_lowerCAmelCase:Union[str, Any]									=  AudioLDMPipeline(**a__)
											_lowerCAmelCase:List[str]									=  audioldm_pipe.to(a__)
											audioldm_pipe.set_progress_bar_config(disable=a__)

											_lowerCAmelCase:Tuple									=  self.get_dummy_inputs(a__)
											_lowerCAmelCase:int									=  '''egg cracking'''
											_lowerCAmelCase:Union[str, Any]									=  audioldm_pipe(**a__     ,negative_prompt=a__)
											_lowerCAmelCase:Dict									=  output.audios[0]

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

											_lowerCAmelCase:Optional[int]									=  audio[:10]
											_lowerCAmelCase:Optional[Any]									=  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       __UpperCamelCase     (							self      :	Optional[Any])						->       List[Any]:




											"""simple docstring"""







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

											_lowerCAmelCase:Tuple									=  '''A hammer hitting a wooden surface'''

											# test num_waveforms_per_prompt=1 (default)
											_lowerCAmelCase:str									=  audioldm_pipe(a__     ,num_inference_steps=2).audios

											assert audios.shape == (1, 256)

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

											assert audios.shape == (batch_size, 256)

											# test num_waveforms_per_prompt for single prompt
											_lowerCAmelCase:Any									=  2
											_lowerCAmelCase:Tuple									=  audioldm_pipe(a__     ,num_inference_steps=2     ,num_waveforms_per_prompt=a__).audios

											assert audios.shape == (num_waveforms_per_prompt, 256)

											# test num_waveforms_per_prompt for batch of prompts
											_lowerCAmelCase:str									=  2
											_lowerCAmelCase:List[Any]									=  audioldm_pipe(
											    [prompt] * batch_size     ,num_inference_steps=2     ,num_waveforms_per_prompt=a__).audios

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





						def       __UpperCamelCase     (							self      :	Optional[Any])						->       Dict:




											"""simple docstring"""







											_lowerCAmelCase:Optional[Any]									=  '''cpu'''  # ensure determinism for the device-dependent torch.Generator
											_lowerCAmelCase:Dict									=  self.get_dummy_components()
											_lowerCAmelCase:Optional[Any]									=  AudioLDMPipeline(**a__)
											_lowerCAmelCase:List[str]									=  audioldm_pipe.to(a__)
											audioldm_pipe.set_progress_bar_config(disable=a__)
											_lowerCAmelCase:Optional[Any]									=  audioldm_pipe.vocoder.config.sampling_rate

											_lowerCAmelCase:Tuple									=  self.get_dummy_inputs(a__)
											_lowerCAmelCase:Optional[Any]									=  audioldm_pipe(audio_length_in_s=0.016     ,**a__)
											_lowerCAmelCase:List[Any]									=  output.audios[0]

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

											_lowerCAmelCase:List[str]									=  audioldm_pipe(audio_length_in_s=0.032     ,**a__)
											_lowerCAmelCase:Optional[int]									=  output.audios[0]

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





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




											"""simple docstring"""







											_lowerCAmelCase:Optional[Any]									=  self.get_dummy_components()
											_lowerCAmelCase:Tuple									=  AudioLDMPipeline(**a__)
											_lowerCAmelCase:Dict									=  audioldm_pipe.to(a__)
											audioldm_pipe.set_progress_bar_config(disable=a__)

											_lowerCAmelCase:Optional[int]									=  ['''hey''']

											_lowerCAmelCase:List[str]									=  audioldm_pipe(a__     ,num_inference_steps=1)
											_lowerCAmelCase:Tuple									=  output.audios.shape
											assert audio_shape == (1, 256)

											_lowerCAmelCase:Any									=  audioldm_pipe.vocoder.config
											config.model_in_dim *= 2
											_lowerCAmelCase:Optional[Any]									=  SpeechTaHifiGan(a__).to(a__)
											_lowerCAmelCase:int									=  audioldm_pipe(a__     ,num_inference_steps=1)
											_lowerCAmelCase: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       __UpperCamelCase     (							self      :	Optional[Any])						->       List[Any]:




											"""simple docstring"""







											self._test_attention_slicing_forward_pass(test_mean_pixel_difference=a__)





						def       __UpperCamelCase     (							self      :	Dict)						->       Optional[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       __UpperCamelCase     (							self      :	Any)						->       Tuple:




											"""simple docstring"""







											self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=a__)




@slow
class   a__			(       unittest.TestCase  ):





						def       __UpperCamelCase     (							self      :	Tuple)						->       Optional[Any]:




											"""simple docstring"""







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





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




											"""simple docstring"""







											_lowerCAmelCase:Optional[int]									=  torch.Generator(device=a__).manual_seed(a__)
											_lowerCAmelCase:Tuple									=  np.random.RandomState(a__).standard_normal((1, 8, 128, 16))
											_lowerCAmelCase:List[str]									=  torch.from_numpy(a__).to(device=a__     ,dtype=a__)
											_lowerCAmelCase:Dict									=  {
											    '''prompt''': '''A hammer hitting a wooden surface''',
											    '''latents''': latents,
											    '''generator''': generator,
											    '''num_inference_steps''': 3,
											    '''guidance_scale''': 2.5,
											}
											return inputs





						def       __UpperCamelCase     (							self      :	Dict)						->       int:




											"""simple docstring"""







											_lowerCAmelCase:str									=  AudioLDMPipeline.from_pretrained('''cvssp/audioldm''')
											_lowerCAmelCase:Optional[Any]									=  audioldm_pipe.to(a__)
											audioldm_pipe.set_progress_bar_config(disable=a__)

											_lowerCAmelCase:Optional[int]									=  self.get_inputs(a__)
											_lowerCAmelCase:Optional[Any]									=  25
											_lowerCAmelCase:int									=  audioldm_pipe(**a__).audios[0]

											assert audio.ndim == 1
											assert len(a__) == 8_1920

											_lowerCAmelCase:int									=  audio[7_7230:7_7240]
											_lowerCAmelCase:Optional[Any]									=  np.array(
											    [-0.4884, -0.4607, 0.0023, 0.5007, 0.5896, 0.5151, 0.3813, -0.0208, -0.3687, -0.4315])
											_lowerCAmelCase:Dict									=  np.abs(expected_slice - audio_slice).max()
											assert max_diff < 1E-2







						def       __UpperCamelCase     (							self      :	List[str])						->       str:




											"""simple docstring"""







											_lowerCAmelCase:Union[str, Any]									=  AudioLDMPipeline.from_pretrained('''cvssp/audioldm''')
											_lowerCAmelCase:List[Any]									=  LMSDiscreteScheduler.from_config(audioldm_pipe.scheduler.config)
											_lowerCAmelCase:Union[str, Any]									=  audioldm_pipe.to(a__)
											audioldm_pipe.set_progress_bar_config(disable=a__)

											_lowerCAmelCase:Optional[Any]									=  self.get_inputs(a__)
											_lowerCAmelCase:Union[str, Any]									=  audioldm_pipe(**a__).audios[0]

											assert audio.ndim == 1
											assert len(a__) == 8_1920

											_lowerCAmelCase:Tuple									=  audio[2_7780:2_7790]
											_lowerCAmelCase:Optional[Any]									=  np.array([-0.2131, -0.0873, -0.0124, -0.0189, 0.0569, 0.1373, 0.1883, 0.2886, 0.3297, 0.2212])
											_lowerCAmelCase:Tuple									=  np.abs(expected_slice - audio_slice).max()
											assert max_diff < 3E-2






