



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 							__snake_case		(	_lowercase		,unittest.TestCase		):
							_a      =					AudioLDMPipeline
							_a      =					TEXT_TO_AUDIO_PARAMS
							_a      =					TEXT_TO_AUDIO_BATCH_PARAMS
							_a      =					frozenset(
							    [
							        '''num_inference_steps''',
							        '''num_waveforms_per_prompt''',
							        '''generator''',
							        '''latents''',
							        '''output_type''',
							        '''return_dict''',
							        '''callback''',
							        '''callback_steps''',
							    ]		)




							def   UpperCAmelCase__     (			self	:			List[Any]):
									torch.manual_seed(0)
									lowerCAmelCase_     :	List[Any]							   =					UNetaDConditionModel(
									    block_out_channels=(3_2, 6_4)							,							layers_per_block=2							,							sample_size=3_2							,							in_channels=4							,							out_channels=4							,							down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')							,							up_block_types=('''CrossAttnUpBlock2D''', '''UpBlock2D''')							,							cross_attention_dim=(3_2, 6_4)							,							class_embed_type='''simple_projection'''							,							projection_class_embeddings_input_dim=3_2							,							class_embeddings_concat=__A							,							)
									lowerCAmelCase_     :	List[str]							   =					DDIMScheduler(
									    beta_start=0.0_0085							,							beta_end=0.012							,							beta_schedule='''scaled_linear'''							,							clip_sample=__A							,							set_alpha_to_one=__A							,							)
									torch.manual_seed(0)
									lowerCAmelCase_     :	Any							   =					AutoencoderKL(
									    block_out_channels=[3_2, 6_4]							,							in_channels=1							,							out_channels=1							,							down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D''']							,							up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D''']							,							latent_channels=4							,							)
									torch.manual_seed(0)
									lowerCAmelCase_     :	str							   =					ClapTextConfig(
									    bos_token_id=0							,							eos_token_id=2							,							hidden_size=3_2							,							intermediate_size=3_7							,							layer_norm_eps=1e-05							,							num_attention_heads=4							,							num_hidden_layers=5							,							pad_token_id=1							,							vocab_size=1_0_0_0							,							projection_dim=3_2							,							)
									lowerCAmelCase_     :	int							   =					ClapTextModelWithProjection(__A)
									lowerCAmelCase_     :	str							   =					RobertaTokenizer.from_pretrained('''hf-internal-testing/tiny-random-roberta'''							,							model_max_length=7_7)

									lowerCAmelCase_     :	List[str]							   =					SpeechTaHifiGanConfig(
									    model_in_dim=8							,							sampling_rate=1_6_0_0_0							,							upsample_initial_channel=1_6							,							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_     :	Dict							   =					{
									    """unet""": unet,
									    """scheduler""": scheduler,
									    """vae""": vae,
									    """text_encoder""": text_encoder,
									    """tokenizer""": tokenizer,
									    """vocoder""": vocoder,
									}
									return components




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




							def   UpperCAmelCase__     (			self	:			Optional[Any]):
									lowerCAmelCase_     :	Any							   =					"""cpu"""  # ensure determinism for the device-dependent torch.Generator

									lowerCAmelCase_     :	Tuple							   =					self.get_dummy_components()
									lowerCAmelCase_     :	Dict							   =					AudioLDMPipeline(**__A)
									lowerCAmelCase_     :	int							   =					audioldm_pipe.to(__A)
									audioldm_pipe.set_progress_bar_config(disable=__A)

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

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

									lowerCAmelCase_     :	str							   =					audio[:1_0]
									lowerCAmelCase_     :	List[str]							   =					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	:			Union[str, Any]):
									lowerCAmelCase_     :	str							   =					self.get_dummy_components()
									lowerCAmelCase_     :	List[str]							   =					AudioLDMPipeline(**__A)
									lowerCAmelCase_     :	Any							   =					audioldm_pipe.to(__A)
									lowerCAmelCase_     :	Any							   =					audioldm_pipe.to(__A)
									audioldm_pipe.set_progress_bar_config(disable=__A)

									lowerCAmelCase_     :	int							   =					self.get_dummy_inputs(__A)
									lowerCAmelCase_     :	List[str]							   =					3 * [inputs["""prompt"""]]

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

									lowerCAmelCase_     :	Any							   =					self.get_dummy_inputs(__A)
									lowerCAmelCase_     :	Optional[Any]							   =					3 * [inputs.pop('''prompt''')]

									lowerCAmelCase_     :	str							   =					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_     :	int							   =					audioldm_pipe.text_encoder(
									    __A							,							)
									lowerCAmelCase_     :	Optional[int]							   =					prompt_embeds.text_embeds
									# additional L_2 normalization over each hidden-state
									lowerCAmelCase_     :	Optional[int]							   =					F.normalize(__A							,							dim=-1)

									lowerCAmelCase_     :	List[str]							   =					prompt_embeds

									# forward
									lowerCAmelCase_     :	Union[str, Any]							   =					audioldm_pipe(**__A)
									lowerCAmelCase_     :	str							   =					output.audios[0]

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




							def   UpperCAmelCase__     (			self	:			Optional[int]):
									lowerCAmelCase_     :	Tuple							   =					self.get_dummy_components()
									lowerCAmelCase_     :	str							   =					AudioLDMPipeline(**__A)
									lowerCAmelCase_     :	Union[str, Any]							   =					audioldm_pipe.to(__A)
									lowerCAmelCase_     :	Optional[int]							   =					audioldm_pipe.to(__A)
									audioldm_pipe.set_progress_bar_config(disable=__A)

									lowerCAmelCase_     :	str							   =					self.get_dummy_inputs(__A)
									lowerCAmelCase_     :	Dict							   =					3 * ["""this is a negative prompt"""]
									lowerCAmelCase_     :	List[Any]							   =					negative_prompt
									lowerCAmelCase_     :	Tuple							   =					3 * [inputs["""prompt"""]]

									# forward
									lowerCAmelCase_     :	Union[str, Any]							   =					audioldm_pipe(**__A)
									lowerCAmelCase_     :	Tuple							   =					output.audios[0]

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

									lowerCAmelCase_     :	Tuple							   =					[]
									for p in [prompt, negative_prompt]:
											lowerCAmelCase_     :	Any							   =					audioldm_pipe.tokenizer(
											    __A							,							padding='''max_length'''							,							max_length=audioldm_pipe.tokenizer.model_max_length							,							truncation=__A							,							return_tensors='''pt'''							,							)
											lowerCAmelCase_     :	Union[str, Any]							   =					text_inputs["""input_ids"""].to(__A)

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

											embeds.append(__A)

									lowerCAmelCase_     :	Optional[Any]							   =					embeds

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

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




							def   UpperCAmelCase__     (			self	:			Any):
									lowerCAmelCase_     :	List[str]							   =					"""cpu"""  # ensure determinism for the device-dependent torch.Generator
									lowerCAmelCase_     :	Union[str, Any]							   =					self.get_dummy_components()
									lowerCAmelCase_     :	Dict							   =					PNDMScheduler(skip_prk_steps=__A)
									lowerCAmelCase_     :	Any							   =					AudioLDMPipeline(**__A)
									lowerCAmelCase_     :	List[Any]							   =					audioldm_pipe.to(__A)
									audioldm_pipe.set_progress_bar_config(disable=__A)

									lowerCAmelCase_     :	Tuple							   =					self.get_dummy_inputs(__A)
									lowerCAmelCase_     :	int							   =					"""egg cracking"""
									lowerCAmelCase_     :	List[str]							   =					audioldm_pipe(**__A							,							negative_prompt=__A)
									lowerCAmelCase_     :	str							   =					output.audios[0]

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

									lowerCAmelCase_     :	List[Any]							   =					audio[:1_0]
									lowerCAmelCase_     :	Union[str, 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	:			Union[str, Any]):
									lowerCAmelCase_     :	int							   =					"""cpu"""  # ensure determinism for the device-dependent torch.Generator
									lowerCAmelCase_     :	Optional[int]							   =					self.get_dummy_components()
									lowerCAmelCase_     :	Any							   =					PNDMScheduler(skip_prk_steps=__A)
									lowerCAmelCase_     :	Union[str, Any]							   =					AudioLDMPipeline(**__A)
									lowerCAmelCase_     :	Optional[Any]							   =					audioldm_pipe.to(__A)
									audioldm_pipe.set_progress_bar_config(disable=__A)

									lowerCAmelCase_     :	List[str]							   =					"""A hammer hitting a wooden surface"""

									# test num_waveforms_per_prompt=1 (default)
									lowerCAmelCase_     :	Dict							   =					audioldm_pipe(__A							,							num_inference_steps=2).audios

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

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

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

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

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

									# test num_waveforms_per_prompt for batch of prompts
									lowerCAmelCase_     :	Union[str, Any]							   =					2
									lowerCAmelCase_     :	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, 2_5_6)




							def   UpperCAmelCase__     (			self	:			Any):
									lowerCAmelCase_     :	int							   =					"""cpu"""  # ensure determinism for the device-dependent torch.Generator
									lowerCAmelCase_     :	str							   =					self.get_dummy_components()
									lowerCAmelCase_     :	Union[str, Any]							   =					AudioLDMPipeline(**__A)
									lowerCAmelCase_     :	Optional[int]							   =					audioldm_pipe.to(__A)
									audioldm_pipe.set_progress_bar_config(disable=__A)
									lowerCAmelCase_     :	int							   =					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_     :	Union[str, Any]							   =					output.audios[0]

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

									lowerCAmelCase_     :	Dict							   =					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	:			int):
									lowerCAmelCase_     :	List[Any]							   =					self.get_dummy_components()
									lowerCAmelCase_     :	Dict							   =					AudioLDMPipeline(**__A)
									lowerCAmelCase_     :	Union[str, Any]							   =					audioldm_pipe.to(__A)
									audioldm_pipe.set_progress_bar_config(disable=__A)

									lowerCAmelCase_     :	int							   =					["""hey"""]

									lowerCAmelCase_     :	int							   =					audioldm_pipe(__A							,							num_inference_steps=1)
									lowerCAmelCase_     :	List[Any]							   =					output.audios.shape
									assert audio_shape == (1, 2_5_6)

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




							def   UpperCAmelCase__     (			self	:			int):
									self._test_attention_slicing_forward_pass(test_mean_pixel_difference=__A)




							def   UpperCAmelCase__     (			self	:			str):
									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	:			Optional[Any]):
									self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=__A)





@slow
class 							__snake_case		(	unittest.TestCase		):




							def   UpperCAmelCase__     (			self	:			Dict):
									super().tearDown()
									gc.collect()
									torch.cuda.empty_cache()




							def   UpperCAmelCase__     (			self	:			str							,							A_	:			List[str]							,							A_	:			Dict="cpu"							,							A_	:			int=torch.floataa							,							A_	:			List[str]=0):
									lowerCAmelCase_     :	str							   =					torch.Generator(device=__A).manual_seed(__A)
									lowerCAmelCase_     :	str							   =					np.random.RandomState(__A).standard_normal((1, 8, 1_2_8, 1_6))
									lowerCAmelCase_     :	str							   =					torch.from_numpy(__A).to(device=__A							,							dtype=__A)
									lowerCAmelCase_     :	Tuple							   =					{
									    """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):
									lowerCAmelCase_     :	Any							   =					AudioLDMPipeline.from_pretrained('''cvssp/audioldm''')
									lowerCAmelCase_     :	Optional[int]							   =					audioldm_pipe.to(__A)
									audioldm_pipe.set_progress_bar_config(disable=__A)

									lowerCAmelCase_     :	Optional[Any]							   =					self.get_inputs(__A)
									lowerCAmelCase_     :	Dict							   =					2_5
									lowerCAmelCase_     :	Tuple							   =					audioldm_pipe(**__A).audios[0]

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

									lowerCAmelCase_     :	Tuple							   =					audio[7_7_2_3_0:7_7_2_4_0]
									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_     :	Optional[Any]							   =					np.abs(expected_slice - audio_slice).max()
									assert max_diff < 1e-2







							def   UpperCAmelCase__     (			self	:			List[Any]):
									lowerCAmelCase_     :	int							   =					AudioLDMPipeline.from_pretrained('''cvssp/audioldm''')
									lowerCAmelCase_     :	Any							   =					LMSDiscreteScheduler.from_config(audioldm_pipe.scheduler.config)
									lowerCAmelCase_     :	List[Any]							   =					audioldm_pipe.to(__A)
									audioldm_pipe.set_progress_bar_config(disable=__A)

									lowerCAmelCase_     :	Tuple							   =					self.get_inputs(__A)
									lowerCAmelCase_     :	Dict							   =					audioldm_pipe(**__A).audios[0]

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

									lowerCAmelCase_     :	str							   =					audio[2_7_7_8_0:2_7_7_9_0]
									lowerCAmelCase_     :	str							   =					np.array([-0.2131, -0.0873, -0.0124, -0.0189, 0.0569, 0.1373, 0.1883, 0.2886, 0.3297, 0.2212])
									lowerCAmelCase_     :	Union[str, Any]							   =					np.abs(expected_slice - audio_slice).max()
									assert max_diff < 3e-2








from sympy import diff, lambdify, symbols
from sympy.functions import *  # noqa: F403
def 							__SCREAMING_SNAKE_CASE     (   a__    :   str			,a__    :   complex			,a__    :   str = "x"			,a__    :   float = 10**-10			,a__    :   int = 1			,)					->				complex:
	__A :			Tuple		    =			symbols(a__       )
	__A :			List[str]		    =			lambdify(a__			,a__       )
	__A :			Any		    =			lambdify(a__			,diff(a__			,a__       )       )

	__A :			Dict		    =			starting_point

	while True:
		if diff_function(a__       ) != 0:
			__A :			Optional[int]		    =			prev_guess - multiplicity * func(a__       ) / diff_function(
			    a__       )
		else:
			raise ZeroDivisionError("""Could not find root"""       ) from None

		# Precision is checked by comparing the difference of consecutive guesses
		if abs(next_guess - prev_guess       ) < precision:
			return next_guess

		__A :			List[Any]		    =			next_guess


# Let's Execute
if __name__ == "__main__":
			# Find root of trigonometric function
			# Find value of pi
			print(f"""The root of sin(x) = 0 is {newton_raphson("sin(x)", 2)}""")

			# Find root of polynomial
			# Find fourth Root of 5
			print(f"""The root of x**4 - 5 = 0 is {newton_raphson("x**4 -5", 0.4 +5J)}""")

			# Find value of e
			print(
			    '''The root of log(y) - 1 = 0 is ''',
			    f"""{newton_raphson("log(y) - 1", 2, variable="y")}""",
			)

			# Exponential Roots
			print(
			    '''The root of exp(x) - 1 = 0 is''',
			    f"""{newton_raphson("exp(x) - 1", 10, precision=0.005)}""",
			)

			# Find root of cos(x)
			print(f"""The root of cos(x) = 0 is {newton_raphson("cos(x)", 0)}""")





