import argparse
import collections
import os
import re
import tempfile

import pandas as pd
from datasets import Dataset
from huggingface_hub import hf_hub_download, upload_folder

from transformers.utils import direct_transformers_import


# All paths are set with the intent you should run this script from the root of the repo with the command
# python utils/update_metadata.py
snake_case      =    "src/transformers"


# This is to make sure the transformers module imported is the one in the repo.
snake_case      =    direct_transformers_import(TRANSFORMERS_PATH)


# Regexes that match TF/Flax/PT model names.
snake_case      =    re.compile(r"TF(.*)(?:Model|Encoder|Decoder|ForConditionalGeneration)")
snake_case      =    re.compile(r"Flax(.*)(?:Model|Encoder|Decoder|ForConditionalGeneration)")
# Will match any TF or Flax model too so need to be in an else branch afterthe two previous regexes.
snake_case      =    re.compile(r"(.*)(?:Model|Encoder|Decoder|ForConditionalGeneration)")


# Fill this with tuples (pipeline_tag, model_mapping, auto_model)
snake_case      =    [
    ("pretraining", "MODEL_FOR_PRETRAINING_MAPPING_NAMES", "AutoModelForPreTraining"),
    ("feature-extraction", "MODEL_MAPPING_NAMES", "AutoModel"),
    ("audio-classification", "MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING_NAMES", "AutoModelForAudioClassification"),
    ("text-generation", "MODEL_FOR_CAUSAL_LM_MAPPING_NAMES", "AutoModelForCausalLM"),
    ("automatic-speech-recognition", "MODEL_FOR_CTC_MAPPING_NAMES", "AutoModelForCTC"),
    ("image-classification", "MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING_NAMES", "AutoModelForImageClassification"),
    ("image-segmentation", "MODEL_FOR_IMAGE_SEGMENTATION_MAPPING_NAMES", "AutoModelForImageSegmentation"),
    ("fill-mask", "MODEL_FOR_MASKED_LM_MAPPING_NAMES", "AutoModelForMaskedLM"),
    ("object-detection", "MODEL_FOR_OBJECT_DETECTION_MAPPING_NAMES", "AutoModelForObjectDetection"),
    (
        "zero-shot-object-detection",
        "MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING_NAMES",
        "AutoModelForZeroShotObjectDetection",
    ),
    ("question-answering", "MODEL_FOR_QUESTION_ANSWERING_MAPPING_NAMES", "AutoModelForQuestionAnswering"),
    ("text2text-generation", "MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING_NAMES", "AutoModelForSeq2SeqLM"),
    ("text-classification", "MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING_NAMES", "AutoModelForSequenceClassification"),
    ("automatic-speech-recognition", "MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING_NAMES", "AutoModelForSpeechSeq2Seq"),
    (
        "table-question-answering",
        "MODEL_FOR_TABLE_QUESTION_ANSWERING_MAPPING_NAMES",
        "AutoModelForTableQuestionAnswering",
    ),
    ("token-classification", "MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING_NAMES", "AutoModelForTokenClassification"),
    ("multiple-choice", "MODEL_FOR_MULTIPLE_CHOICE_MAPPING_NAMES", "AutoModelForMultipleChoice"),
    (
        "next-sentence-prediction",
        "MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING_NAMES",
        "AutoModelForNextSentencePrediction",
    ),
    (
        "audio-frame-classification",
        "MODEL_FOR_AUDIO_FRAME_CLASSIFICATION_MAPPING_NAMES",
        "AutoModelForAudioFrameClassification",
    ),
    ("audio-xvector", "MODEL_FOR_AUDIO_XVECTOR_MAPPING_NAMES", "AutoModelForAudioXVector"),
    (
        "document-question-answering",
        "MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING_NAMES",
        "AutoModelForDocumentQuestionAnswering",
    ),
    (
        "visual-question-answering",
        "MODEL_FOR_VISUAL_QUESTION_ANSWERING_MAPPING_NAMES",
        "AutoModelForVisualQuestionAnswering",
    ),
    ("image-to-text", "MODEL_FOR_FOR_VISION_2_SEQ_MAPPING_NAMES", "AutoModelForVision2Seq"),
    (
        "zero-shot-image-classification",
        "MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING_NAMES",
        "AutoModelForZeroShotImageClassification",
    ),
    ("depth-estimation", "MODEL_FOR_DEPTH_ESTIMATION_MAPPING_NAMES", "AutoModelForDepthEstimation"),
    ("video-classification", "MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING_NAMES", "AutoModelForVideoClassification"),
    ("mask-generation", "MODEL_FOR_MASK_GENERATION_MAPPING_NAMES", "AutoModelForMaskGeneration"),
]






def        UpperCamelCase_							(			lowerCAmelCase__  ):



					"""simple docstring"""

					_lowerCAmelCase			:		Optional[Any]          = re.finditer(".+?(?:(?<=[a-z])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])|$)"						,	lowercase__  )
					return [m.group(0  ) for m in matches]






def        UpperCamelCase_							(			):



					"""simple docstring"""

					_lowerCAmelCase			:		Optional[Any]          = transformers_module.models.auto.configuration_auto.CONFIG_MAPPING_NAMES
					_lowerCAmelCase			:		int          = {
					    config.replace("Config"						,	""  ): model_type for model_type, config in config_maping_names.items()
					}

					# Dictionaries flagging if each model prefix has a backend in PT/TF/Flax.
					_lowerCAmelCase			:		str          = collections.defaultdict(lowercase__  )
					_lowerCAmelCase			:		Optional[Any]          = collections.defaultdict(lowercase__  )
					_lowerCAmelCase			:		List[Any]          = collections.defaultdict(lowercase__  )

					# Let's lookup through all transformers object (once) and find if models are supported by a given backend.
					for attr_name in dir(lowercase__  ):
										_lowerCAmelCase			:		Union[str, Any]          = None
										if _re_tf_models.match(lowercase__  ) is not None:
															_lowerCAmelCase			:		Union[str, Any]          = tf_models
															_lowerCAmelCase			:		List[Any]          = _re_tf_models.match(lowercase__  ).groups()[0]
										elif _re_flax_models.match(lowercase__  ) is not None:
															_lowerCAmelCase			:		int          = flax_models
															_lowerCAmelCase			:		Optional[Any]          = _re_flax_models.match(lowercase__  ).groups()[0]
										elif _re_pt_models.match(lowercase__  ) is not None:
															_lowerCAmelCase			:		Any          = pt_models
															_lowerCAmelCase			:		Optional[Any]          = _re_pt_models.match(lowercase__  ).groups()[0]

										if lookup_dict is not None:
															while len(lowercase__  ) > 0:
																				if attr_name in model_prefix_to_model_type:
																									_lowerCAmelCase			:		Any          = True
																									break
																				# Try again after removing the last word in the name
																				_lowerCAmelCase			:		Tuple          = "".join(camel_case_split(lowercase__  )[:-1]  )

					_lowerCAmelCase			:		Optional[Any]          = set(list(pt_models.keys()  ) + list(tf_models.keys()  ) + list(flax_models.keys()  )  )
					_lowerCAmelCase			:		List[Any]          = list(lowercase__  )
					all_models.sort()

					_lowerCAmelCase			:		List[str]          = {"model_type": all_models}
					_lowerCAmelCase			:		Any          = [pt_models[t] for t in all_models]
					_lowerCAmelCase			:		Any          = [tf_models[t] for t in all_models]
					_lowerCAmelCase			:		Optional[int]          = [flax_models[t] for t in all_models]

					# Now let's use the auto-mapping names to make sure
					_lowerCAmelCase			:		Any          = {}
					for t in all_models:
										if t in transformers_module.models.auto.processing_auto.PROCESSOR_MAPPING_NAMES:
															_lowerCAmelCase			:		Optional[Any]          = "AutoProcessor"
										elif t in transformers_module.models.auto.tokenization_auto.TOKENIZER_MAPPING_NAMES:
															_lowerCAmelCase			:		Optional[int]          = "AutoTokenizer"
										elif t in transformers_module.models.auto.feature_extraction_auto.FEATURE_EXTRACTOR_MAPPING_NAMES:
															_lowerCAmelCase			:		Optional[int]          = "AutoFeatureExtractor"
										else:
															# Default to AutoTokenizer if a model has nothing, for backward compatibility.
															_lowerCAmelCase			:		Optional[int]          = "AutoTokenizer"

					_lowerCAmelCase			:		Any          = [processors[t] for t in all_models]

					return pd.DataFrame(lowercase__  )






def        UpperCamelCase_							(			lowerCAmelCase__  ):



					"""simple docstring"""

					_lowerCAmelCase			:		Union[str, Any]          = [
					    transformers_module.models.auto.modeling_auto,
					    transformers_module.models.auto.modeling_tf_auto,
					    transformers_module.models.auto.modeling_flax_auto,
					]
					for pipeline_tag, model_mapping, auto_class in PIPELINE_TAGS_AND_AUTO_MODELS:
										_lowerCAmelCase			:		str          = [model_mapping, f"""TF_{model_mapping}""", f"""FLAX_{model_mapping}"""]
										_lowerCAmelCase			:		Tuple          = [auto_class, f"""TF_{auto_class}""", f"""Flax_{auto_class}"""]
										# Loop through all three frameworks
										for module, cls, mapping in zip(lowercase__						,	lowercase__						,	lowercase__  ):
															# The type of pipeline may not exist in this framework
															if not hasattr(lowercase__						,	lowercase__  ):
																				continue
															# First extract all model_names
															_lowerCAmelCase			:		Optional[Any]          = []
															for name in getattr(lowercase__						,	lowercase__  ).values():
																				if isinstance(lowercase__						,	lowercase__  ):
																									model_names.append(lowercase__  )
																				else:
																									model_names.extend(list(lowercase__  )  )

            # Add pipeline tag and auto model class for those models
															table.update({model_name: (pipeline_tag, cls) for model_name in model_names}  )

					return table






def        UpperCamelCase_							(			lowerCAmelCase__						,	lowerCAmelCase__  ):



					"""simple docstring"""

					_lowerCAmelCase			:		Optional[Any]          = get_frameworks_table()
					_lowerCAmelCase			:		int          = Dataset.from_pandas(lowercase__  )

					_lowerCAmelCase			:		Optional[int]          = hf_hub_download(
					    "huggingface/transformers-metadata"						,	"pipeline_tags.json"						,	repo_type="dataset"						,	token=lowercase__  )
					_lowerCAmelCase			:		List[str]          = Dataset.from_json(lowercase__  )
					_lowerCAmelCase			:		Tuple          = {
					    tags_dataset[i]["model_class"]: (tags_dataset[i]["pipeline_tag"], tags_dataset[i]["auto_class"])
					    for i in range(len(lowercase__  )  )
					}
					_lowerCAmelCase			:		Optional[Any]          = update_pipeline_and_auto_class_table(lowercase__  )

					# Sort the model classes to avoid some nondeterministic updates to create false update commits.
					_lowerCAmelCase			:		List[Any]          = sorted(table.keys()  )
					_lowerCAmelCase			:		List[str]          = pd.DataFrame(
					    {
					        "model_class": model_classes,
					        "pipeline_tag": [table[m][0] for m in model_classes],
					        "auto_class": [table[m][1] for m in model_classes],
					    }  )
					_lowerCAmelCase			:		Optional[Any]          = Dataset.from_pandas(lowercase__  )

					with tempfile.TemporaryDirectory() as tmp_dir:
										frameworks_dataset.to_json(os.path.join(lowercase__						,	"frameworks.json"  )  )
										tags_dataset.to_json(os.path.join(lowercase__						,	"pipeline_tags.json"  )  )

										if commit_sha is not None:
															_lowerCAmelCase			:		List[str]          = (
															    f"""Update with commit {commit_sha}\n\nSee: """
															    f"""https://github.com/huggingface/transformers/commit/{commit_sha}"""
															)
										else:
															_lowerCAmelCase			:		List[Any]          = "Update"

										upload_folder(
										    repo_id="huggingface/transformers-metadata"						,	folder_path=lowercase__						,	repo_type="dataset"						,	token=lowercase__						,	commit_message=lowercase__						,	)






def        UpperCamelCase_							(			):



					"""simple docstring"""

					_lowerCAmelCase			:		int          = {tag: cls for tag, _, cls in PIPELINE_TAGS_AND_AUTO_MODELS}
					_lowerCAmelCase			:		Tuple          = transformers_module.pipelines.SUPPORTED_TASKS
					_lowerCAmelCase			:		List[Any]          = []
					for key in pipeline_tasks:
										if key not in in_table:
															_lowerCAmelCase			:		Union[str, Any]          = pipeline_tasks[key]["pt"]
															if isinstance(lowercase__						,	(list, tuple)  ):
																				_lowerCAmelCase			:		Tuple          = model[0]
															_lowerCAmelCase			:		List[str]          = model.__name__
															if model not in in_table.values():
																				missing.append(lowercase__  )

					if len(lowercase__  ) > 0:
										_lowerCAmelCase			:		List[str]          = ", ".join(lowercase__  )
										raise ValueError(
										    "The following pipeline tags are not present in the `PIPELINE_TAGS_AND_AUTO_MODELS` constant inside "
										    f"""`utils/update_metadata.py`: {msg}. Please add them!"""  )


if __name__ == "__main__":
						snake_case      =    argparse.ArgumentParser()
						parser.add_argument("--token", type=str, help="The token to use to push to the transformers-metadata dataset.")
						parser.add_argument("--commit_sha", type=str, help="The sha of the commit going with this update.")
						parser.add_argument("--check-only", action="store_true", help="Activate to just check all pipelines are present.")
						snake_case      =    parser.parse_args()

						if args.check_only:
												check_pipeline_tags()
						else:
												update_metadata(args.token, args.commit_sha)









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






			"""simple docstring"""




			__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       __lowerCAmelCase			(     self				):

				"""simple docstring"""


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

				snake_case_   		=			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=__UpperCamelCase			,					)

				snake_case_   		=			SpeechTaHifiGan(__UpperCamelCase				)

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


			def       __lowerCAmelCase			(     self			,					__UpperCamelCase			,					__UpperCamelCase=0				):

				"""simple docstring"""


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


			def       __lowerCAmelCase			(     self				):

				"""simple docstring"""


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

				snake_case_   		=			self.get_dummy_components()
				snake_case_   		=			AudioLDMPipeline(**__UpperCamelCase				)
				snake_case_   		=			audioldm_pipe.to(__UpperCamelCase				)
				audioldm_pipe.set_progress_bar_config(disable=__UpperCamelCase				)

				snake_case_   		=			self.get_dummy_inputs(__UpperCamelCase				)
				snake_case_   		=			audioldm_pipe(**__UpperCamelCase				)
				snake_case_   		=			output.audios[0]

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

				snake_case_   		=			audio[:10]
				snake_case_   		=			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       __lowerCAmelCase			(     self				):

				"""simple docstring"""


				snake_case_   		=			self.get_dummy_components()
				snake_case_   		=			AudioLDMPipeline(**__UpperCamelCase				)
				snake_case_   		=			audioldm_pipe.to(__UpperCamelCase				)
				snake_case_   		=			audioldm_pipe.to(__UpperCamelCase				)
				audioldm_pipe.set_progress_bar_config(disable=__UpperCamelCase				)

				snake_case_   		=			self.get_dummy_inputs(__UpperCamelCase				)
				snake_case_   		=			3 * [inputs['prompt']]

				# forward
				snake_case_   		=			audioldm_pipe(**__UpperCamelCase				)
				snake_case_   		=			output.audios[0]

				snake_case_   		=			self.get_dummy_inputs(__UpperCamelCase				)
				snake_case_   		=			3 * [inputs.pop('prompt'				)]

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

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

				snake_case_   		=			prompt_embeds

				# forward
				snake_case_   		=			audioldm_pipe(**__UpperCamelCase				)
				snake_case_   		=			output.audios[0]

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


			def       __lowerCAmelCase			(     self				):

				"""simple docstring"""


				snake_case_   		=			self.get_dummy_components()
				snake_case_   		=			AudioLDMPipeline(**__UpperCamelCase				)
				snake_case_   		=			audioldm_pipe.to(__UpperCamelCase				)
				snake_case_   		=			audioldm_pipe.to(__UpperCamelCase				)
				audioldm_pipe.set_progress_bar_config(disable=__UpperCamelCase				)

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

				# forward
				snake_case_   		=			audioldm_pipe(**__UpperCamelCase				)
				snake_case_   		=			output.audios[0]

				snake_case_   		=			self.get_dummy_inputs(__UpperCamelCase				)
				snake_case_   		=			3 * [inputs.pop('prompt'				)]

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

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

					embeds.append(__UpperCamelCase				)

				snake_case_		,							snake_case_   		=			embeds

				# forward
				snake_case_   		=			audioldm_pipe(**__UpperCamelCase				)
				snake_case_   		=			output.audios[0]

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


			def       __lowerCAmelCase			(     self				):

				"""simple docstring"""


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

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

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

				snake_case_   		=			audio[:10]
				snake_case_   		=			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       __lowerCAmelCase			(     self				):

				"""simple docstring"""


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

				snake_case_   		=			'A hammer hitting a wooden surface'

				# test num_waveforms_per_prompt=1 (default)
				snake_case_   		=			audioldm_pipe(__UpperCamelCase			,					num_inference_steps=2				).audios

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

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

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

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

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


			def       __lowerCAmelCase			(     self				):

				"""simple docstring"""


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

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

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

				snake_case_   		=			audioldm_pipe(audio_length_in_s=0.032			,					**__UpperCamelCase				)
				snake_case_   		=			output.audios[0]

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


			def       __lowerCAmelCase			(     self				):

				"""simple docstring"""


				snake_case_   		=			self.get_dummy_components()
				snake_case_   		=			AudioLDMPipeline(**__UpperCamelCase				)
				snake_case_   		=			audioldm_pipe.to(__UpperCamelCase				)
				audioldm_pipe.set_progress_bar_config(disable=__UpperCamelCase				)

				snake_case_   		=			['hey']

				snake_case_   		=			audioldm_pipe(__UpperCamelCase			,					num_inference_steps=1				)
				snake_case_   		=			output.audios.shape
				assert audio_shape == (1, 2_56)

				snake_case_   		=			audioldm_pipe.vocoder.config
				config.model_in_dim *= 2
				snake_case_   		=			SpeechTaHifiGan(__UpperCamelCase				).to(__UpperCamelCase				)
				snake_case_   		=			audioldm_pipe(__UpperCamelCase			,					num_inference_steps=1				)
				snake_case_   		=			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				):

				"""simple docstring"""


				self._test_attention_slicing_forward_pass(test_mean_pixel_difference=__UpperCamelCase				)


			def       __lowerCAmelCase			(     self				):

				"""simple docstring"""


				self._test_inference_batch_single_identical(test_mean_pixel_difference=__UpperCamelCase				)







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

				"""simple docstring"""


				self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=__UpperCamelCase				)







@slow
class SCREAMING_SNAKE_CASE	(		unittest.TestCase				):






			"""simple docstring"""




			def       __lowerCAmelCase			(     self				):

				"""simple docstring"""


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


			def       __lowerCAmelCase			(     self			,					__UpperCamelCase			,					__UpperCamelCase="cpu"			,					__UpperCamelCase=torch.floataa			,					__UpperCamelCase=0				):

				"""simple docstring"""


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


			def       __lowerCAmelCase			(     self				):

				"""simple docstring"""


				snake_case_   		=			AudioLDMPipeline.from_pretrained('cvssp/audioldm'				)
				snake_case_   		=			audioldm_pipe.to(__UpperCamelCase				)
				audioldm_pipe.set_progress_bar_config(disable=__UpperCamelCase				)

				snake_case_   		=			self.get_inputs(__UpperCamelCase				)
				snake_case_   		=			25
				snake_case_   		=			audioldm_pipe(**__UpperCamelCase				).audios[0]

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

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







			def       __lowerCAmelCase			(     self				):

				"""simple docstring"""


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

				snake_case_   		=			self.get_inputs(__UpperCamelCase				)
				snake_case_   		=			audioldm_pipe(**__UpperCamelCase				).audios[0]

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

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