




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

     '''simple docstring'''





     lowerCAmelCase    :	str       		=  AudioLDMPipeline
     lowerCAmelCase    :	str       		=  TEXT_TO_AUDIO_PARAMS
     lowerCAmelCase    :	Union[str, Any]       		=  TEXT_TO_AUDIO_BATCH_PARAMS
     lowerCAmelCase    :	str       		=  frozenset(
         [
             'num_inference_steps',
             'num_waveforms_per_prompt',
             'generator',
             'latents',
             'output_type',
             'return_dict',
             'callback',
             'callback_steps',
         ]      )
     def   lowerCamelCase_       (     self       :      int    ):
         torch.manual_seed(0    )
         UpperCAmelCase_										=					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 ,   )
         UpperCAmelCase_										=					DDIMScheduler(
             beta_start=0.00_085 ,   beta_end=0.012 ,   beta_schedule='''scaled_linear''' ,   clip_sample=_A ,   set_alpha_to_one=_A ,   )
         torch.manual_seed(0    )
         UpperCAmelCase_										=					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    )
         UpperCAmelCase_										=					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 ,   )
         UpperCAmelCase_										=					ClapTextModelWithProjection(_A    )
         UpperCAmelCase_										=					RobertaTokenizer.from_pretrained('''hf-internal-testing/tiny-random-roberta''' ,   model_max_length=77    )

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

         UpperCAmelCase_										=					SpeechTaHifiGan(_A    )

         UpperCAmelCase_										=					{
             'unet': unet,
             'scheduler': scheduler,
             'vae': vae,
             'text_encoder': text_encoder,
             'tokenizer': tokenizer,
             'vocoder': vocoder,
         }
         return components
     def   lowerCamelCase_       (     self       :      List[str] ,   __snake_case       :      Dict ,   __snake_case       :      List[Any]=0    ):
         if str(_A    ).startswith('''mps'''    ):
             UpperCAmelCase_										=					torch.manual_seed(_A    )
         else:
             UpperCAmelCase_										=					torch.Generator(device=_A    ).manual_seed(_A    )
         UpperCAmelCase_										=					{
             'prompt': 'A hammer hitting a wooden surface',
             'generator': generator,
             'num_inference_steps': 2,
             'guidance_scale': 6.0,
         }
         return inputs
     def   lowerCamelCase_       (     self       :      Optional[Any]    ):
         UpperCAmelCase_										=					'cpu'  # ensure determinism for the device-dependent torch.Generator

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

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

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

         UpperCAmelCase_										=					audio[:10]
         UpperCAmelCase_										=					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       :      Optional[Any]    ):
         UpperCAmelCase_										=					self.get_dummy_components()
         UpperCAmelCase_										=					AudioLDMPipeline(**_A    )
         UpperCAmelCase_										=					audioldm_pipe.to(_A    )
         UpperCAmelCase_										=					audioldm_pipe.to(_A    )
         audioldm_pipe.set_progress_bar_config(disable=_A    )

         UpperCAmelCase_										=					self.get_dummy_inputs(_A    )
         UpperCAmelCase_										=					3 * [inputs['prompt']]

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

         UpperCAmelCase_										=					self.get_dummy_inputs(_A    )
         UpperCAmelCase_										=					3 * [inputs.pop('''prompt'''    )]

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

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

         UpperCAmelCase_										=					prompt_embeds

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

         assert np.abs(audio_a - audio_a    ).max() < 1E-2
     def   lowerCamelCase_       (     self       :      Tuple    ):
         UpperCAmelCase_										=					self.get_dummy_components()
         UpperCAmelCase_										=					AudioLDMPipeline(**_A    )
         UpperCAmelCase_										=					audioldm_pipe.to(_A    )
         UpperCAmelCase_										=					audioldm_pipe.to(_A    )
         audioldm_pipe.set_progress_bar_config(disable=_A    )

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

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

         UpperCAmelCase_										=					self.get_dummy_inputs(_A    )
         UpperCAmelCase_										=					3 * [inputs.pop('''prompt'''    )]

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

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

             embeds.append(_A    )

         UpperCAmelCase_										=					embeds

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

         assert np.abs(audio_a - audio_a    ).max() < 1E-2
     def   lowerCamelCase_       (     self       :      Optional[Any]    ):
         UpperCAmelCase_										=					'cpu'  # ensure determinism for the device-dependent torch.Generator
         UpperCAmelCase_										=					self.get_dummy_components()
         UpperCAmelCase_										=					PNDMScheduler(skip_prk_steps=_A    )
         UpperCAmelCase_										=					AudioLDMPipeline(**_A    )
         UpperCAmelCase_										=					audioldm_pipe.to(_A    )
         audioldm_pipe.set_progress_bar_config(disable=_A    )

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

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

         UpperCAmelCase_										=					audio[:10]
         UpperCAmelCase_										=					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       :      List[str]    ):
         UpperCAmelCase_										=					'cpu'  # ensure determinism for the device-dependent torch.Generator
         UpperCAmelCase_										=					self.get_dummy_components()
         UpperCAmelCase_										=					PNDMScheduler(skip_prk_steps=_A    )
         UpperCAmelCase_										=					AudioLDMPipeline(**_A    )
         UpperCAmelCase_										=					audioldm_pipe.to(_A    )
         audioldm_pipe.set_progress_bar_config(disable=_A    )

         UpperCAmelCase_										=					'A hammer hitting a wooden surface'

         # test num_waveforms_per_prompt=1 (default)
         UpperCAmelCase_										=					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
         UpperCAmelCase_										=					2
         UpperCAmelCase_										=					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
         UpperCAmelCase_										=					2
         UpperCAmelCase_										=					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
         UpperCAmelCase_										=					2
         UpperCAmelCase_										=					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   lowerCamelCase_       (     self       :      List[Any]    ):
         UpperCAmelCase_										=					'cpu'  # ensure determinism for the device-dependent torch.Generator
         UpperCAmelCase_										=					self.get_dummy_components()
         UpperCAmelCase_										=					AudioLDMPipeline(**_A    )
         UpperCAmelCase_										=					audioldm_pipe.to(_A    )
         audioldm_pipe.set_progress_bar_config(disable=_A    )
         UpperCAmelCase_										=					audioldm_pipe.vocoder.config.sampling_rate

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

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

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

         assert audio.ndim == 1
         assert len(_A    ) / vocoder_sampling_rate == 0.032
     def   lowerCamelCase_       (     self       :      Tuple    ):
         UpperCAmelCase_										=					self.get_dummy_components()
         UpperCAmelCase_										=					AudioLDMPipeline(**_A    )
         UpperCAmelCase_										=					audioldm_pipe.to(_A    )
         audioldm_pipe.set_progress_bar_config(disable=_A    )

         UpperCAmelCase_										=					['hey']

         UpperCAmelCase_										=					audioldm_pipe(_A ,   num_inference_steps=1    )
         UpperCAmelCase_										=					output.audios.shape
         assert audio_shape == (1, 2_56)

         UpperCAmelCase_										=					audioldm_pipe.vocoder.config
         config.model_in_dim *= 2
         UpperCAmelCase_										=					SpeechTaHifiGan(_A    ).to(_A    )
         UpperCAmelCase_										=					audioldm_pipe(_A ,   num_inference_steps=1    )
         UpperCAmelCase_										=					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   lowerCamelCase_       (     self       :      Optional[Any]    ):
         self._test_attention_slicing_forward_pass(test_mean_pixel_difference=_A    )
     def   lowerCamelCase_       (     self       :      Tuple    ):
         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   lowerCamelCase_       (     self       :      List[Any]    ):
         self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=_A    )



@slow
class       a					(       unittest.TestCase      ):

     '''simple docstring'''





     def   lowerCamelCase_       (     self       :      int    ):
         super().tearDown()
         gc.collect()
         torch.cuda.empty_cache()
     def   lowerCamelCase_       (     self       :      int ,   __snake_case       :      Union[str, Any] ,   __snake_case       :      Any="cpu" ,   __snake_case       :      Optional[Any]=torch.floataa ,   __snake_case       :      Any=0    ):
         UpperCAmelCase_										=					torch.Generator(device=_A    ).manual_seed(_A    )
         UpperCAmelCase_										=					np.random.RandomState(_A    ).standard_normal((1, 8, 1_28, 16)    )
         UpperCAmelCase_										=					torch.from_numpy(_A    ).to(device=_A ,   dtype=_A    )
         UpperCAmelCase_										=					{
             'prompt': 'A hammer hitting a wooden surface',
             'latents': latents,
             'generator': generator,
             'num_inference_steps': 3,
             'guidance_scale': 2.5,
         }
         return inputs
     def   lowerCamelCase_       (     self       :      Optional[Any]    ):
         UpperCAmelCase_										=					AudioLDMPipeline.from_pretrained('''cvssp/audioldm'''    )
         UpperCAmelCase_										=					audioldm_pipe.to(_A    )
         audioldm_pipe.set_progress_bar_config(disable=_A    )

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

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

         UpperCAmelCase_										=					audio[7_72_30:7_72_40]
         UpperCAmelCase_										=					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]    )
         UpperCAmelCase_										=					np.abs(expected_slice - audio_slice    ).max()
         assert max_diff < 1E-2




     def   lowerCamelCase_       (     self       :      Dict    ):
         UpperCAmelCase_										=					AudioLDMPipeline.from_pretrained('''cvssp/audioldm'''    )
         UpperCAmelCase_										=					LMSDiscreteScheduler.from_config(audioldm_pipe.scheduler.config    )
         UpperCAmelCase_										=					audioldm_pipe.to(_A    )
         audioldm_pipe.set_progress_bar_config(disable=_A    )

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

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

         UpperCAmelCase_										=					audio[2_77_80:2_77_90]
         UpperCAmelCase_										=					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]    )
         UpperCAmelCase_										=					np.abs(expected_slice - audio_slice    ).max()
         assert max_diff < 3E-2











from __future__ import annotations

from fractions import Fraction




def  SCREAMING_SNAKE_CASE     (	__UpperCamelCase      :						int	,					__UpperCamelCase      :						int				)  ->							bool:
    return (
        num != den and num % 10 == den // 10 and (num // 10) / (den % 10) == num / den
    )




def  SCREAMING_SNAKE_CASE     (	__UpperCamelCase      :						int				)  ->							list[str]:
    UpperCAmelCase_										=					[]
    UpperCAmelCase_										=					11
    UpperCAmelCase_										=					int('''1''' + '''0''' * digit_len				)
    for num in range(__UpperCamelCase	,					__UpperCamelCase				):
        while den <= 99:
            if (num != den) and (num % 10 == den // 10) and (den % 10 != 0):
                if is_digit_cancelling(__UpperCamelCase	,					__UpperCamelCase				):
                    solutions.append(f'{num}/{den}'				)
            den += 1
        num += 1
        UpperCAmelCase_										=					10
    return solutions




def  SCREAMING_SNAKE_CASE     (	__UpperCamelCase      :						int = 2				)  ->							int:
    UpperCAmelCase_										=					1.0
    for fraction in fraction_list(__UpperCamelCase				):
        UpperCAmelCase_										=					Fraction(__UpperCamelCase				)
        result *= frac.denominator / frac.numerator
    return int(__UpperCamelCase				)


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





