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


   def __UpperCAmelCase       (   self				:	Tuple)      ->					Optional[int]:
         torch.manual_seed(0)
         lowercase_     =      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=__lowerCAmelCase   ,		)
         lowercase_     =      DDIMScheduler(
             beta_start=0.0_0085   ,		beta_end=0.012   ,		beta_schedule="scaled_linear"   ,		clip_sample=__lowerCAmelCase   ,		set_alpha_to_one=__lowerCAmelCase   ,		)
         torch.manual_seed(0)
         lowercase_     =      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)
         lowercase_     =      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   ,		)
         lowercase_     =      ClapTextModelWithProjection(__lowerCAmelCase)
         lowercase_     =      RobertaTokenizer.from_pretrained("hf-internal-testing/tiny-random-roberta"   ,		model_max_length=77)

         lowercase_     =      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=__lowerCAmelCase   ,		)

         lowercase_     =      SpeechTaHifiGan(__lowerCAmelCase)

         lowercase_     =      {
             "unet": unet,
             "scheduler": scheduler,
             "vae": vae,
             "text_encoder": text_encoder,
             "tokenizer": tokenizer,
             "vocoder": vocoder,
         }
         return components


   def __UpperCAmelCase       (   self				:	Optional[Any]   ,		__lowerCAmelCase				:	Optional[int]   ,		__lowerCAmelCase				:	Dict=0)      ->					List[Any]:
         if str(__lowerCAmelCase).startswith("mps"):
               lowercase_     =      torch.manual_seed(__lowerCAmelCase)
         else:
               lowercase_     =      torch.Generator(device=__lowerCAmelCase).manual_seed(__lowerCAmelCase)
         lowercase_     =      {
             "prompt": "A hammer hitting a wooden surface",
             "generator": generator,
             "num_inference_steps": 2,
             "guidance_scale": 6.0,
         }
         return inputs


   def __UpperCAmelCase       (   self				:	Any)      ->					Dict:
         lowercase_     =      "cpu"  # ensure determinism for the device-dependent torch.Generator

         lowercase_     =      self.get_dummy_components()
         lowercase_     =      AudioLDMPipeline(**__lowerCAmelCase)
         lowercase_     =      audioldm_pipe.to(__lowerCAmelCase)
         audioldm_pipe.set_progress_bar_config(disable=__lowerCAmelCase)

         lowercase_     =      self.get_dummy_inputs(__lowerCAmelCase)
         lowercase_     =      audioldm_pipe(**__lowerCAmelCase)
         lowercase_     =      output.audios[0]

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

         lowercase_     =      audio[:10]
         lowercase_     =      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				:	List[Any])      ->					Tuple:
         lowercase_     =      self.get_dummy_components()
         lowercase_     =      AudioLDMPipeline(**__lowerCAmelCase)
         lowercase_     =      audioldm_pipe.to(__lowerCAmelCase)
         lowercase_     =      audioldm_pipe.to(__lowerCAmelCase)
         audioldm_pipe.set_progress_bar_config(disable=__lowerCAmelCase)

         lowercase_     =      self.get_dummy_inputs(__lowerCAmelCase)
         lowercase_     =      3 * [inputs["prompt"]]

         # forward
         lowercase_     =      audioldm_pipe(**__lowerCAmelCase)
         lowercase_     =      output.audios[0]

         lowercase_     =      self.get_dummy_inputs(__lowerCAmelCase)
         lowercase_     =      3 * [inputs.pop("prompt")]

         lowercase_     =      audioldm_pipe.tokenizer(
             __lowerCAmelCase   ,		padding="max_length"   ,		max_length=audioldm_pipe.tokenizer.model_max_length   ,		truncation=__lowerCAmelCase   ,		return_tensors="pt"   ,		)
         lowercase_     =      text_inputs["input_ids"].to(__lowerCAmelCase)

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

         lowercase_     =      prompt_embeds

         # forward
         lowercase_     =      audioldm_pipe(**__lowerCAmelCase)
         lowercase_     =      output.audios[0]

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


   def __UpperCAmelCase       (   self				:	Optional[Any])      ->					Any:
         lowercase_     =      self.get_dummy_components()
         lowercase_     =      AudioLDMPipeline(**__lowerCAmelCase)
         lowercase_     =      audioldm_pipe.to(__lowerCAmelCase)
         lowercase_     =      audioldm_pipe.to(__lowerCAmelCase)
         audioldm_pipe.set_progress_bar_config(disable=__lowerCAmelCase)

         lowercase_     =      self.get_dummy_inputs(__lowerCAmelCase)
         lowercase_     =      3 * ["this is a negative prompt"]
         lowercase_     =      negative_prompt
         lowercase_     =      3 * [inputs["prompt"]]

         # forward
         lowercase_     =      audioldm_pipe(**__lowerCAmelCase)
         lowercase_     =      output.audios[0]

         lowercase_     =      self.get_dummy_inputs(__lowerCAmelCase)
         lowercase_     =      3 * [inputs.pop("prompt")]

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

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

               embeds.append(__lowerCAmelCase)

         lowercase_ ,							lowercase_     =      embeds

         # forward
         lowercase_     =      audioldm_pipe(**__lowerCAmelCase)
         lowercase_     =      output.audios[0]

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


   def __UpperCAmelCase       (   self				:	Optional[int])      ->					List[Any]:
         lowercase_     =      "cpu"  # ensure determinism for the device-dependent torch.Generator
         lowercase_     =      self.get_dummy_components()
         lowercase_     =      PNDMScheduler(skip_prk_steps=__lowerCAmelCase)
         lowercase_     =      AudioLDMPipeline(**__lowerCAmelCase)
         lowercase_     =      audioldm_pipe.to(__lowerCAmelCase)
         audioldm_pipe.set_progress_bar_config(disable=__lowerCAmelCase)

         lowercase_     =      self.get_dummy_inputs(__lowerCAmelCase)
         lowercase_     =      "egg cracking"
         lowercase_     =      audioldm_pipe(**__lowerCAmelCase   ,		negative_prompt=__lowerCAmelCase)
         lowercase_     =      output.audios[0]

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

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

         lowercase_     =      "A hammer hitting a wooden surface"

         # test num_waveforms_per_prompt=1 (default)
         lowercase_     =      audioldm_pipe(__lowerCAmelCase   ,		num_inference_steps=2).audios

         assert audios.shape == (1, 256)

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

         assert audios.shape == (batch_size, 256)

         # test num_waveforms_per_prompt for single prompt
         lowercase_     =      2
         lowercase_     =      audioldm_pipe(__lowerCAmelCase   ,		num_inference_steps=2   ,		num_waveforms_per_prompt=__lowerCAmelCase).audios

         assert audios.shape == (num_waveforms_per_prompt, 256)

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

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


   def __UpperCAmelCase       (   self				:	int)      ->					List[Any]:
         lowercase_     =      "cpu"  # ensure determinism for the device-dependent torch.Generator
         lowercase_     =      self.get_dummy_components()
         lowercase_     =      AudioLDMPipeline(**__lowerCAmelCase)
         lowercase_     =      audioldm_pipe.to(__lowerCAmelCase)
         audioldm_pipe.set_progress_bar_config(disable=__lowerCAmelCase)
         lowercase_     =      audioldm_pipe.vocoder.config.sampling_rate

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

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

         lowercase_     =      audioldm_pipe(audio_length_in_s=0.032   ,		**__lowerCAmelCase)
         lowercase_     =      output.audios[0]

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


   def __UpperCAmelCase       (   self				:	Optional[Any])      ->					int:
         lowercase_     =      self.get_dummy_components()
         lowercase_     =      AudioLDMPipeline(**__lowerCAmelCase)
         lowercase_     =      audioldm_pipe.to(__lowerCAmelCase)
         audioldm_pipe.set_progress_bar_config(disable=__lowerCAmelCase)

         lowercase_     =      ["hey"]

         lowercase_     =      audioldm_pipe(__lowerCAmelCase   ,		num_inference_steps=1)
         lowercase_     =      output.audios.shape
         assert audio_shape == (1, 256)

         lowercase_     =      audioldm_pipe.vocoder.config
         config.model_in_dim *= 2
         lowercase_     =      SpeechTaHifiGan(__lowerCAmelCase).to(__lowerCAmelCase)
         lowercase_     =      audioldm_pipe(__lowerCAmelCase   ,		num_inference_steps=1)
         lowercase_     =      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[int])      ->					Tuple:
         self._test_attention_slicing_forward_pass(test_mean_pixel_difference=__lowerCAmelCase)


   def __UpperCAmelCase       (   self				:	Any)      ->					str:
         self._test_inference_batch_single_identical(test_mean_pixel_difference=__lowerCAmelCase)


   @unittest.skipIf(
       torch_device != "cuda" or not is_xformers_available()   ,		reason="XFormers attention is only available with CUDA and `xformers` installed"   ,		)
   def __UpperCAmelCase       (   self				:	str)      ->					Optional[Any]:
         self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=__lowerCAmelCase)





@slow
class 							lowercase						(						unittest.TestCase ):


   def __UpperCAmelCase       (   self				:	Optional[int])      ->					Tuple:
         super().tearDown()
         gc.collect()
         torch.cuda.empty_cache()


   def __UpperCAmelCase       (   self				:	Optional[Any]   ,		__lowerCAmelCase				:	Optional[Any]   ,		__lowerCAmelCase				:	List[Any]="cpu"   ,		__lowerCAmelCase				:	Optional[Any]=torch.floataa   ,		__lowerCAmelCase				:	int=0)      ->					int:
         lowercase_     =      torch.Generator(device=__lowerCAmelCase).manual_seed(__lowerCAmelCase)
         lowercase_     =      np.random.RandomState(__lowerCAmelCase).standard_normal((1, 8, 128, 16))
         lowercase_     =      torch.from_numpy(__lowerCAmelCase).to(device=__lowerCAmelCase   ,		dtype=__lowerCAmelCase)
         lowercase_     =      {
             "prompt": "A hammer hitting a wooden surface",
             "latents": latents,
             "generator": generator,
             "num_inference_steps": 3,
             "guidance_scale": 2.5,
         }
         return inputs


   def __UpperCAmelCase       (   self				:	List[Any])      ->					int:
         lowercase_     =      AudioLDMPipeline.from_pretrained("cvssp/audioldm")
         lowercase_     =      audioldm_pipe.to(__lowerCAmelCase)
         audioldm_pipe.set_progress_bar_config(disable=__lowerCAmelCase)

         lowercase_     =      self.get_inputs(__lowerCAmelCase)
         lowercase_     =      25
         lowercase_     =      audioldm_pipe(**__lowerCAmelCase).audios[0]

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

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


   def __UpperCAmelCase       (   self				:	Any)      ->					Any:
         lowercase_     =      AudioLDMPipeline.from_pretrained("cvssp/audioldm")
         lowercase_     =      LMSDiscreteScheduler.from_config(audioldm_pipe.scheduler.config)
         lowercase_     =      audioldm_pipe.to(__lowerCAmelCase)
         audioldm_pipe.set_progress_bar_config(disable=__lowerCAmelCase)

         lowercase_     =      self.get_inputs(__lowerCAmelCase)
         lowercase_     =      audioldm_pipe(**__lowerCAmelCase).audios[0]

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

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







'''simple docstring'''

import json
import sys


def __a (	__lowerCamelCase			:						Optional[int] ,		__lowerCamelCase			:						Union[str, Any]				)	->							Optional[Any]:
      '''simple docstring'''


      with open(__lowerCamelCase ,		encoding="utf-8"				) as f:
            lowercase_     =      json.load(__lowerCamelCase				)

      lowercase_     =      ["<details>", "<summary>Show updated benchmarks!</summary>", " "]

      for benchmark_name in sorted(__lowerCamelCase				):
            lowercase_     =      results[benchmark_name]

            lowercase_     =      benchmark_name.split("/"				)[-1]
            output_md.append(f'### Benchmark: {benchmark_file_name}'				)

            lowercase_     =      "| metric |"
            lowercase_     =      "|--------|"
            lowercase_     =      "| new / old (diff) |"
            for metric_name in sorted(__lowerCamelCase				):
                  lowercase_     =      benchmark_res[metric_name]
                  lowercase_     =      metric_vals["new"]
                  lowercase_     =      metric_vals.get("old" ,		__lowerCamelCase				)
                  lowercase_     =      metric_vals.get("diff" ,		__lowerCamelCase				)

                  lowercase_     =      f' {new_val:f}' if isinstance(__lowerCamelCase ,		(int, float)				) else "None"

                  if old_val is not None:
                        val_str += f' / {old_val:f}' if isinstance(__lowerCamelCase ,		(int, float)				) else "None"
                  if dif_val is not None:
                        val_str += f' ({dif_val:f})' if isinstance(__lowerCamelCase ,		(int, float)				) else "None"

                  title += " " + metric_name + " |"
                  lines += "---|"
                  value += val_str + " |"

            output_md += [title, lines, value, " "]

      output_md.append("</details>"				)

      with open(__lowerCamelCase ,		"w" ,		encoding="utf-8"				) as f:
            f.writelines("\n".join(__lowerCamelCase				)				)


if __name__ == "__main__":
       lowerCAmelCase_ : List[Any]						  =      sys.argv[1]
       lowerCAmelCase_ : Any						  =      sys.argv[2]

       format_json_to_md(input_json_file, output_md_file)






