





import json
import os
import shutil
import tempfile
import unittest
from multiprocessing import get_context
from pathlib import Path

import datasets
import numpy as np
from datasets import load_dataset
from parameterized import parameterized

from transformers import AutoProcessor
from transformers.models.wavaveca import WavaVecaCTCTokenizer, WavaVecaFeatureExtractor
from transformers.models.wavaveca.tokenization_wavaveca import VOCAB_FILES_NAMES
from transformers.testing_utils import require_pyctcdecode, require_torch, require_torchaudio, slow
from transformers.utils import FEATURE_EXTRACTOR_NAME, is_pyctcdecode_available, is_torch_available

from ..wavaveca.test_feature_extraction_wavaveca import floats_list


if is_pyctcdecode_available():
      from huggingface_hub import snapshot_download
      from pyctcdecode import BeamSearchDecoderCTC

      from transformers.models.wavaveca_with_lm import WavaVecaProcessorWithLM
      from transformers.models.wavaveca_with_lm.processing_wavaveca_with_lm import WavaVecaDecoderWithLMOutput

if is_torch_available():
      from transformers import WavaVecaForCTC





@require_pyctcdecode
class 				A_				(      unittest.TestCase	):







       """simple docstring"""





       def    __UpperCAmelCase (    self	:	Tuple  )						->					Optional[Any]:
         _lowercase							= "| <pad> <unk> <s> </s> a b c d e f g h i j k".split()
         _lowercase							= dict(zip(__a						,range(len(__a  )  )  )  )

         _lowercase							= {
             "unk_token": "<unk>",
             "bos_token": "<s>",
             "eos_token": "</s>",
         }
         _lowercase							= {
             "feature_size": 1,
             "padding_value": 0.0,
             "sampling_rate": 1_6000,
             "return_attention_mask": False,
             "do_normalize": True,
         }

         _lowercase							= tempfile.mkdtemp()
         _lowercase							= os.path.join(self.tmpdirname						,VOCAB_FILES_NAMES['vocab_file']  )
         _lowercase							= os.path.join(self.tmpdirname						,__a  )
         with open(self.vocab_file						,'w'						,encoding='utf-8'  ) as fp:
           fp.write(json.dumps(__a  ) + '\n'  )

         with open(self.feature_extraction_file						,'w'						,encoding='utf-8'  ) as fp:
           fp.write(json.dumps(__a  ) + '\n'  )

         # load decoder from hub
         _lowercase							= "hf-internal-testing/ngram-beam-search-decoder"







       def    __UpperCAmelCase (    self	:	Tuple						,**__A	:	Union[str, Any]  )						->					int:
         _lowercase							= self.add_kwargs_tokens_map.copy()
         kwargs.update(__a  )
         return WavaVecaCTCTokenizer.from_pretrained(self.tmpdirname						,**__a  )







       def    __UpperCAmelCase (    self	:	Tuple						,**__A	:	List[str]  )						->					int:
         return WavaVecaFeatureExtractor.from_pretrained(self.tmpdirname						,**__a  )







       def    __UpperCAmelCase (    self	:	str						,**__A	:	Optional[int]  )						->					Tuple:
         return BeamSearchDecoderCTC.load_from_hf_hub(self.decoder_name						,**__a  )







       def    __UpperCAmelCase (    self	:	Union[str, Any]  )						->					List[str]:
         shutil.rmtree(self.tmpdirname  )







       def    __UpperCAmelCase (    self	:	Tuple  )						->					Union[str, Any]:
         _lowercase							= self.get_tokenizer()
         _lowercase							= self.get_feature_extractor()
         _lowercase							= self.get_decoder()

         _lowercase							= WavaVecaProcessorWithLM(tokenizer=__a						,feature_extractor=__a						,decoder=__a  )

         processor.save_pretrained(self.tmpdirname  )
         _lowercase							= WavaVecaProcessorWithLM.from_pretrained(self.tmpdirname  )

         # tokenizer
         self.assertEqual(processor.tokenizer.get_vocab()						,tokenizer.get_vocab()  )
         self.assertIsInstance(processor.tokenizer						,__a  )

         # feature extractor
         self.assertEqual(processor.feature_extractor.to_json_string()						,feature_extractor.to_json_string()  )
         self.assertIsInstance(processor.feature_extractor						,__a  )

         # decoder
         self.assertEqual(processor.decoder._alphabet.labels						,decoder._alphabet.labels  )
         self.assertEqual(
             processor.decoder.model_container[decoder._model_key]._unigram_set						,decoder.model_container[decoder._model_key]._unigram_set						,)
         self.assertIsInstance(processor.decoder						,__a  )







       def    __UpperCAmelCase (    self	:	Dict  )						->					Optional[int]:
         _lowercase							= WavaVecaProcessorWithLM(
             tokenizer=self.get_tokenizer()						,feature_extractor=self.get_feature_extractor()						,decoder=self.get_decoder()  )
         processor.save_pretrained(self.tmpdirname  )

         # make sure that error is thrown when decoder alphabet doesn't match
         _lowercase							= WavaVecaProcessorWithLM.from_pretrained(
             self.tmpdirname						,alpha=5.0						,beta=3.0						,score_boundary=-7.0						,unk_score_offset=3  )

         # decoder
         self.assertEqual(processor.language_model.alpha						,5.0  )
         self.assertEqual(processor.language_model.beta						,3.0  )
         self.assertEqual(processor.language_model.score_boundary						,-7.0  )
         self.assertEqual(processor.language_model.unk_score_offset						,3  )







       def    __UpperCAmelCase (    self	:	Dict  )						->					Union[str, Any]:
         _lowercase							= self.get_tokenizer()
         # add token to trigger raise
         tokenizer.add_tokens(['xx']  )
         with self.assertRaisesRegex(__a						,'include'  ):
           WavaVecaProcessorWithLM(
               tokenizer=__a						,feature_extractor=self.get_feature_extractor()						,decoder=self.get_decoder()  )







       def    __UpperCAmelCase (    self	:	Any  )						->					List[str]:
         _lowercase							= self.get_feature_extractor()
         _lowercase							= self.get_tokenizer()
         _lowercase							= self.get_decoder()

         _lowercase							= WavaVecaProcessorWithLM(tokenizer=__a						,feature_extractor=__a						,decoder=__a  )

         _lowercase							= floats_list((3, 1000)  )

         _lowercase							= feature_extractor(__a						,return_tensors='np'  )
         _lowercase							= processor(__a						,return_tensors='np'  )

         for key in input_feat_extract.keys():
           self.assertAlmostEqual(input_feat_extract[key].sum()						,input_processor[key].sum()						,delta=1e-2  )







       def    __UpperCAmelCase (    self	:	Any  )						->					int:
         _lowercase							= self.get_feature_extractor()
         _lowercase							= self.get_tokenizer()
         _lowercase							= self.get_decoder()

         _lowercase							= WavaVecaProcessorWithLM(tokenizer=__a						,feature_extractor=__a						,decoder=__a  )

         _lowercase							= "This is a test string"

         _lowercase							= processor(text=__a  )

         _lowercase							= tokenizer(__a  )

         for key in encoded_tok.keys():
           self.assertListEqual(encoded_tok[key]						,encoded_processor[key]  )







       def    __UpperCAmelCase (    self	:	List[Any]						,__A	:	Tuple=(2, 10, 16)						,__A	:	int=77  )						->					List[Any]:
         np.random.seed(__a  )
         return np.random.rand(*__a  )







       def    __UpperCAmelCase (    self	:	List[Any]  )						->					Union[str, Any]:
         _lowercase							= self.get_feature_extractor()
         _lowercase							= self.get_tokenizer()
         _lowercase							= self.get_decoder()

         _lowercase							= WavaVecaProcessorWithLM(tokenizer=__a						,feature_extractor=__a						,decoder=__a  )

         _lowercase							= self._get_dummy_logits(shape=(10, 16)						,seed=13  )

         _lowercase							= processor.decode(__a  )

         _lowercase							= decoder.decode_beams(__a  )[0]

         self.assertEqual(decoded_decoder[0]						,decoded_processor.text  )
         self.assertEqual('</s> <s> </s>'						,decoded_processor.text  )
         self.assertEqual(decoded_decoder[-2]						,decoded_processor.logit_score  )
         self.assertEqual(decoded_decoder[-1]						,decoded_processor.lm_score  )







       @parameterized.expand([[None], ['fork'], ['spawn']]  )
       def    __UpperCAmelCase (    self	:	List[str]						,__A	:	Tuple  )						->					Any:
         _lowercase							= self.get_feature_extractor()
         _lowercase							= self.get_tokenizer()
         _lowercase							= self.get_decoder()

         _lowercase							= WavaVecaProcessorWithLM(tokenizer=__a						,feature_extractor=__a						,decoder=__a  )

         _lowercase							= self._get_dummy_logits()

         # note: pool should be instantiated *after* Wav2Vec2ProcessorWithLM.
         #       otherwise, the LM won't be available to the pool's sub-processes.
         # manual logic used to allow parameterized test for both pool=None and pool=Pool(...)
         if pool_context is None:
           _lowercase							= processor.batch_decode(__a  )
         else:
           with get_context(__a  ).Pool() as pool:
             _lowercase							= processor.batch_decode(__a						,__a  )

         _lowercase							= list(__a  )

         with get_context('fork'  ).Pool() as p:
           _lowercase							= decoder.decode_beams_batch(__a						,__a  )

         _lowercase							= [], [], []
         for beams in decoded_beams:
           texts_decoder.append(beams[0][0]  )
           logit_scores_decoder.append(beams[0][-2]  )
           lm_scores_decoder.append(beams[0][-1]  )

         self.assertListEqual(__a						,decoded_processor.text  )
         self.assertListEqual(['<s> <s> </s>', '<s> <s> <s>']						,decoded_processor.text  )
         self.assertListEqual(__a						,decoded_processor.logit_score  )
         self.assertListEqual(__a						,decoded_processor.lm_score  )







       def    __UpperCAmelCase (    self	:	Union[str, Any]  )						->					int:
         _lowercase							= self.get_feature_extractor()
         _lowercase							= self.get_tokenizer()
         _lowercase							= self.get_decoder()

         _lowercase							= WavaVecaProcessorWithLM(tokenizer=__a						,feature_extractor=__a						,decoder=__a  )

         _lowercase							= self._get_dummy_logits()

         _lowercase							= 15
         _lowercase							= -20.0
         _lowercase							= -4.0

         _lowercase							= processor.batch_decode(
             __a						,beam_width=__a						,beam_prune_logp=__a						,token_min_logp=__a						,)
         _lowercase							= decoded_processor_out.text

         _lowercase							= list(__a  )

         with get_context('fork'  ).Pool() as pool:
           _lowercase							= decoder.decode_beams_batch(
               __a						,__a						,beam_width=__a						,beam_prune_logp=__a						,token_min_logp=__a						,)

         _lowercase							= [d[0][0] for d in decoded_decoder_out]
         _lowercase							= [d[0][2] for d in decoded_decoder_out]
         _lowercase							= [d[0][3] for d in decoded_decoder_out]

         self.assertListEqual(__a						,__a  )
         self.assertListEqual(['</s> <s> <s>', '<s> <s> <s>']						,__a  )

         self.assertTrue(np.array_equal(__a						,decoded_processor_out.logit_score  )  )
         self.assertTrue(np.allclose([-20.054, -18.447]						,__a						,atol=1e-3  )  )

         self.assertTrue(np.array_equal(__a						,decoded_processor_out.lm_score  )  )
         self.assertTrue(np.allclose([-15.554, -13.9474]						,__a						,atol=1e-3  )  )







       def    __UpperCAmelCase (    self	:	Any  )						->					Any:
         _lowercase							= self.get_feature_extractor()
         _lowercase							= self.get_tokenizer()
         _lowercase							= self.get_decoder()

         _lowercase							= WavaVecaProcessorWithLM(tokenizer=__a						,feature_extractor=__a						,decoder=__a  )

         _lowercase							= self._get_dummy_logits()

         _lowercase							= 2.0
         _lowercase							= 5.0
         _lowercase							= -20.0
         _lowercase							= True

         _lowercase							= processor.batch_decode(
             __a						,alpha=__a						,beta=__a						,unk_score_offset=__a						,lm_score_boundary=__a						,)
         _lowercase							= decoded_processor_out.text

         _lowercase							= list(__a  )
         decoder.reset_params(
             alpha=__a						,beta=__a						,unk_score_offset=__a						,lm_score_boundary=__a						,)

         with get_context('fork'  ).Pool() as pool:
           _lowercase							= decoder.decode_beams_batch(
               __a						,__a						,)

         _lowercase							= [d[0][0] for d in decoded_decoder_out]

         self.assertListEqual(__a						,__a  )
         self.assertListEqual(['<s> </s> <s> </s> </s>', '</s> </s> <s> </s> </s>']						,__a  )
         _lowercase							= processor.decoder.model_container[processor.decoder._model_key]
         self.assertEqual(lm_model.alpha						,2.0  )
         self.assertEqual(lm_model.beta						,5.0  )
         self.assertEqual(lm_model.unk_score_offset						,-20.0  )
         self.assertEqual(lm_model.score_boundary						,__a  )







       def    __UpperCAmelCase (    self	:	List[Any]  )						->					Dict:
         _lowercase							= WavaVecaProcessorWithLM.from_pretrained('hf-internal-testing/processor_with_lm'  )

         _lowercase							= processor.decoder.model_container[processor.decoder._model_key]
         _lowercase							= Path(language_model._kenlm_model.path.decode('utf-8'  )  ).parent.parent.absolute()

         _lowercase							= os.listdir(__a  )
         _lowercase							= ["alphabet.json", "language_model"]

         downloaded_decoder_files.sort()
         expected_decoder_files.sort()

         # test that only decoder relevant files from
         # https://huggingface.co/hf-internal-testing/processor_with_lm/tree/main
         # are downloaded and none of the rest (e.g. README.md, ...)
         self.assertListEqual(__a						,__a  )







       def    __UpperCAmelCase (    self	:	List[str]  )						->					Optional[Any]:
         _lowercase							= snapshot_download('hf-internal-testing/processor_with_lm'  )

         _lowercase							= WavaVecaProcessorWithLM.from_pretrained(__a  )

         _lowercase							= processor.decoder.model_container[processor.decoder._model_key]
         _lowercase							= Path(language_model._kenlm_model.path.decode('utf-8'  )  ).parent.parent.absolute()

         _lowercase							= os.listdir(__a  )
         _lowercase							= os.listdir(__a  )

         local_decoder_files.sort()
         expected_decoder_files.sort()

         # test that both decoder form hub and local files in cache are the same
         self.assertListEqual(__a						,__a  )







       def    __UpperCAmelCase (    self	:	Dict  )						->					List[str]:
         _lowercase							= WavaVecaProcessorWithLM.from_pretrained('hf-internal-testing/processor_with_lm'  )
         _lowercase							= AutoProcessor.from_pretrained('hf-internal-testing/processor_with_lm'  )

         _lowercase							= floats_list((3, 1000)  )

         _lowercase							= processor_wavaveca(__a						,return_tensors='np'  )
         _lowercase							= processor_auto(__a						,return_tensors='np'  )

         for key in input_wavaveca.keys():
           self.assertAlmostEqual(input_wavaveca[key].sum()						,input_auto[key].sum()						,delta=1e-2  )

         _lowercase							= self._get_dummy_logits()

         _lowercase							= processor_wavaveca.batch_decode(__a  )
         _lowercase							= processor_auto.batch_decode(__a  )

         self.assertListEqual(decoded_wavaveca.text						,decoded_auto.text  )







       def    __UpperCAmelCase (    self	:	Tuple  )						->					Optional[Any]:
         _lowercase							= self.get_feature_extractor()
         _lowercase							= self.get_tokenizer()
         _lowercase							= self.get_decoder()

         _lowercase							= WavaVecaProcessorWithLM(tokenizer=__a						,feature_extractor=__a						,decoder=__a  )

         self.assertListEqual(
             processor.model_input_names						,feature_extractor.model_input_names						,msg='`processor` and `feature_extractor` model input names do not match'						,)







       @staticmethod
       def    __UpperCAmelCase (    __A	:	Optional[Any]						,__A	:	Optional[int]  )						->					int:
         _lowercase							= [d[key] for d in offsets]
         return retrieved_list







       def    __UpperCAmelCase (    self	:	Optional[int]  )						->					Optional[Any]:
         _lowercase							= WavaVecaProcessorWithLM.from_pretrained('hf-internal-testing/processor_with_lm'  )
         _lowercase							= self._get_dummy_logits()[0]

         _lowercase							= processor.decode(__a						,output_word_offsets=__a  )
         # check Wav2Vec2CTCTokenizerOutput keys for word
         self.assertEqual(len(outputs.keys()  )						,4  )
         self.assertTrue('text' in outputs  )
         self.assertTrue('word_offsets' in outputs  )
         self.assertTrue(isinstance(__a						,__a  )  )

         self.assertEqual(' '.join(self.get_from_offsets(outputs['word_offsets']						,'word'  )  )						,outputs.text  )
         self.assertListEqual(self.get_from_offsets(outputs['word_offsets']						,'word'  )						,['<s>', '<s>', '</s>']  )
         self.assertListEqual(self.get_from_offsets(outputs['word_offsets']						,'start_offset'  )						,[0, 2, 4]  )
         self.assertListEqual(self.get_from_offsets(outputs['word_offsets']						,'end_offset'  )						,[1, 3, 5]  )







       def    __UpperCAmelCase (    self	:	int  )						->					Optional[Any]:
         _lowercase							= WavaVecaProcessorWithLM.from_pretrained('hf-internal-testing/processor_with_lm'  )
         _lowercase							= self._get_dummy_logits()

         _lowercase							= processor.batch_decode(__a						,output_word_offsets=__a  )

         # check Wav2Vec2CTCTokenizerOutput keys for word
         self.assertEqual(len(outputs.keys()  )						,4  )
         self.assertTrue('text' in outputs  )
         self.assertTrue('word_offsets' in outputs  )
         self.assertTrue(isinstance(__a						,__a  )  )

         self.assertListEqual(
             [' '.join(self.get_from_offsets(__a						,'word'  )  ) for o in outputs['word_offsets']]						,outputs.text  )
         self.assertListEqual(self.get_from_offsets(outputs['word_offsets'][0]						,'word'  )						,['<s>', '<s>', '</s>']  )
         self.assertListEqual(self.get_from_offsets(outputs['word_offsets'][0]						,'start_offset'  )						,[0, 2, 4]  )
         self.assertListEqual(self.get_from_offsets(outputs['word_offsets'][0]						,'end_offset'  )						,[1, 3, 5]  )







       @slow
       @require_torch
       @require_torchaudio
       def    __UpperCAmelCase (    self	:	Any  )						->					Union[str, Any]:
         import torch

         _lowercase							= load_dataset('common_voice'						,'en'						,split='train'						,streaming=__a  )
         _lowercase							= ds.cast_column('audio'						,datasets.Audio(sampling_rate=1_6000  )  )
         _lowercase							= iter(__a  )
         _lowercase							= next(__a  )

         _lowercase							= AutoProcessor.from_pretrained('patrickvonplaten/wav2vec2-base-100h-with-lm'  )
         _lowercase							= WavaVecaForCTC.from_pretrained('patrickvonplaten/wav2vec2-base-100h-with-lm'  )

         # compare to filename `common_voice_en_100038.mp3` of dataset viewer on https://huggingface.co/datasets/common_voice/viewer/en/train
         _lowercase							= processor(sample['audio']['array']						,return_tensors='pt'  ).input_values

         with torch.no_grad():
           _lowercase							= model(__a  ).logits.cpu().numpy()

         _lowercase							= processor.decode(logits[0]						,output_word_offsets=__a  )

         _lowercase							= model.config.inputs_to_logits_ratio / processor.feature_extractor.sampling_rate
         _lowercase							= [
             {
                 "start_time": d["start_offset"] * time_offset,
                 "end_time": d["end_offset"] * time_offset,
                 "word": d["word"],
             }
             for d in output["word_offsets"]
         ]

         _lowercase							= "WHY DOES MILISANDRA LOOK LIKE SHE WANTS TO CONSUME JOHN SNOW ON THE RIVER AT THE WALL"

         # output words
         self.assertEqual(' '.join(self.get_from_offsets(__a						,'word'  )  )						,__a  )
         self.assertEqual(' '.join(self.get_from_offsets(__a						,'word'  )  )						,output.text  )

         # output times
         _lowercase							= torch.tensor(self.get_from_offsets(__a						,'start_time'  )  )
         _lowercase							= torch.tensor(self.get_from_offsets(__a						,'end_time'  )  )

         # fmt: off
         _lowercase							= torch.tensor([1.4199, 1.6599, 2.2599, 3.0, 3.24, 3.5999, 3.7999, 4.0999, 4.26, 4.94, 5.28, 5.6599, 5.78, 5.94, 6.32, 6.5399, 6.6599]  )
         _lowercase							= torch.tensor([1.5399, 1.8999, 2.9, 3.16, 3.5399, 3.72, 4.0199, 4.1799, 4.76, 5.1599, 5.5599, 5.6999, 5.86, 6.1999, 6.38, 6.6199, 6.94]  )
         # fmt: on

         self.assertTrue(torch.allclose(__a						,__a						,atol=0.01  )  )
         self.assertTrue(torch.allclose(__a						,__a						,atol=0.01  )  )








snake_case 				=       """0.18.2"""

from .configuration_utils import ConfigMixin
from .utils import (
    OptionalDependencyNotAvailable,
    is_flax_available,
    is_inflect_available,
    is_invisible_watermark_available,
    is_k_diffusion_available,
    is_k_diffusion_version,
    is_librosa_available,
    is_note_seq_available,
    is_onnx_available,
    is_scipy_available,
    is_torch_available,
    is_torchsde_available,
    is_transformers_available,
    is_transformers_version,
    is_unidecode_available,
    logging,
)


try:
      if not is_onnx_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      from .utils.dummy_onnx_objects import *  # noqa F403
else:
      from .pipelines import OnnxRuntimeModel

try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      from .utils.dummy_pt_objects import *  # noqa F403
else:
      from .models import (
          AutoencoderKL,
          ControlNetModel,
          ModelMixin,
          PriorTransformer,
          TaFilmDecoder,
          TransformeraDModel,
          UNetaDModel,
          UNetaDConditionModel,
          UNetaDModel,
          UNetaDConditionModel,
          VQModel,
      )
      from .optimization import (
          get_constant_schedule,
          get_constant_schedule_with_warmup,
          get_cosine_schedule_with_warmup,
          get_cosine_with_hard_restarts_schedule_with_warmup,
          get_linear_schedule_with_warmup,
          get_polynomial_decay_schedule_with_warmup,
          get_scheduler,
      )
      from .pipelines import (
          AudioPipelineOutput,
          ConsistencyModelPipeline,
          DanceDiffusionPipeline,
          DDIMPipeline,
          DDPMPipeline,
          DiffusionPipeline,
          DiTPipeline,
          ImagePipelineOutput,
          KarrasVePipeline,
          LDMPipeline,
          LDMSuperResolutionPipeline,
          PNDMPipeline,
          RePaintPipeline,
          ScoreSdeVePipeline,
      )
      from .schedulers import (
          CMStochasticIterativeScheduler,
          DDIMInverseScheduler,
          DDIMParallelScheduler,
          DDIMScheduler,
          DDPMParallelScheduler,
          DDPMScheduler,
          DEISMultistepScheduler,
          DPMSolverMultistepInverseScheduler,
          DPMSolverMultistepScheduler,
          DPMSolverSinglestepScheduler,
          EulerAncestralDiscreteScheduler,
          EulerDiscreteScheduler,
          HeunDiscreteScheduler,
          IPNDMScheduler,
          KarrasVeScheduler,
          KDPMaAncestralDiscreteScheduler,
          KDPMaDiscreteScheduler,
          PNDMScheduler,
          RePaintScheduler,
          SchedulerMixin,
          ScoreSdeVeScheduler,
          UnCLIPScheduler,
          UniPCMultistepScheduler,
          VQDiffusionScheduler,
      )
      from .training_utils import EMAModel

try:
      if not (is_torch_available() and is_scipy_available()):
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      from .utils.dummy_torch_and_scipy_objects import *  # noqa F403
else:
      from .schedulers import LMSDiscreteScheduler

try:
      if not (is_torch_available() and is_torchsde_available()):
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      from .utils.dummy_torch_and_torchsde_objects import *  # noqa F403
else:
      from .schedulers import DPMSolverSDEScheduler

try:
      if not (is_torch_available() and is_transformers_available()):
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      from .utils.dummy_torch_and_transformers_objects import *  # noqa F403
else:
      from .pipelines import (
          AltDiffusionImgaImgPipeline,
          AltDiffusionPipeline,
          AudioLDMPipeline,
          CycleDiffusionPipeline,
          IFImgaImgPipeline,
          IFImgaImgSuperResolutionPipeline,
          IFInpaintingPipeline,
          IFInpaintingSuperResolutionPipeline,
          IFPipeline,
          IFSuperResolutionPipeline,
          ImageTextPipelineOutput,
          KandinskyImgaImgPipeline,
          KandinskyInpaintPipeline,
          KandinskyPipeline,
          KandinskyPriorPipeline,
          KandinskyVaaControlnetImgaImgPipeline,
          KandinskyVaaControlnetPipeline,
          KandinskyVaaImgaImgPipeline,
          KandinskyVaaInpaintPipeline,
          KandinskyVaaPipeline,
          KandinskyVaaPriorEmbaEmbPipeline,
          KandinskyVaaPriorPipeline,
          LDMTextToImagePipeline,
          PaintByExamplePipeline,
          SemanticStableDiffusionPipeline,
          ShapEImgaImgPipeline,
          ShapEPipeline,
          StableDiffusionAttendAndExcitePipeline,
          StableDiffusionControlNetImgaImgPipeline,
          StableDiffusionControlNetInpaintPipeline,
          StableDiffusionControlNetPipeline,
          StableDiffusionDepthaImgPipeline,
          StableDiffusionDiffEditPipeline,
          StableDiffusionImageVariationPipeline,
          StableDiffusionImgaImgPipeline,
          StableDiffusionInpaintPipeline,
          StableDiffusionInpaintPipelineLegacy,
          StableDiffusionInstructPixaPixPipeline,
          StableDiffusionLatentUpscalePipeline,
          StableDiffusionLDMaDPipeline,
          StableDiffusionModelEditingPipeline,
          StableDiffusionPanoramaPipeline,
          StableDiffusionParadigmsPipeline,
          StableDiffusionPipeline,
          StableDiffusionPipelineSafe,
          StableDiffusionPixaPixZeroPipeline,
          StableDiffusionSAGPipeline,
          StableDiffusionUpscalePipeline,
          StableUnCLIPImgaImgPipeline,
          StableUnCLIPPipeline,
          TextToVideoSDPipeline,
          TextToVideoZeroPipeline,
          UnCLIPImageVariationPipeline,
          UnCLIPPipeline,
          UniDiffuserModel,
          UniDiffuserPipeline,
          UniDiffuserTextDecoder,
          VersatileDiffusionDualGuidedPipeline,
          VersatileDiffusionImageVariationPipeline,
          VersatileDiffusionPipeline,
          VersatileDiffusionTextToImagePipeline,
          VideoToVideoSDPipeline,
          VQDiffusionPipeline,
      )

try:
      if not (is_torch_available() and is_transformers_available() and is_invisible_watermark_available()):
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      from .utils.dummy_torch_and_transformers_and_invisible_watermark_objects import *  # noqa F403
else:
      from .pipelines import StableDiffusionXLImgaImgPipeline, StableDiffusionXLPipeline

try:
      if not (is_torch_available() and is_transformers_available() and is_k_diffusion_available()):
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      from .utils.dummy_torch_and_transformers_and_k_diffusion_objects import *  # noqa F403
else:
      from .pipelines import StableDiffusionKDiffusionPipeline

try:
      if not (is_torch_available() and is_transformers_available() and is_onnx_available()):
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      from .utils.dummy_torch_and_transformers_and_onnx_objects import *  # noqa F403
else:
      from .pipelines import (
          OnnxStableDiffusionImgaImgPipeline,
          OnnxStableDiffusionInpaintPipeline,
          OnnxStableDiffusionInpaintPipelineLegacy,
          OnnxStableDiffusionPipeline,
          OnnxStableDiffusionUpscalePipeline,
          StableDiffusionOnnxPipeline,
      )

try:
      if not (is_torch_available() and is_librosa_available()):
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      from .utils.dummy_torch_and_librosa_objects import *  # noqa F403
else:
      from .pipelines import AudioDiffusionPipeline, Mel

try:
      if not (is_transformers_available() and is_torch_available() and is_note_seq_available()):
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      from .utils.dummy_transformers_and_torch_and_note_seq_objects import *  # noqa F403
else:
      from .pipelines import SpectrogramDiffusionPipeline

try:
      if not is_flax_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      from .utils.dummy_flax_objects import *  # noqa F403
else:
      from .models.controlnet_flax import FlaxControlNetModel
      from .models.modeling_flax_utils import FlaxModelMixin
      from .models.unet_ad_condition_flax import FlaxUNetaDConditionModel
      from .models.vae_flax import FlaxAutoencoderKL
      from .pipelines import FlaxDiffusionPipeline
      from .schedulers import (
          FlaxDDIMScheduler,
          FlaxDDPMScheduler,
          FlaxDPMSolverMultistepScheduler,
          FlaxKarrasVeScheduler,
          FlaxLMSDiscreteScheduler,
          FlaxPNDMScheduler,
          FlaxSchedulerMixin,
          FlaxScoreSdeVeScheduler,
      )


try:
      if not (is_flax_available() and is_transformers_available()):
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      from .utils.dummy_flax_and_transformers_objects import *  # noqa F403
else:
      from .pipelines import (
          FlaxStableDiffusionControlNetPipeline,
          FlaxStableDiffusionImgaImgPipeline,
          FlaxStableDiffusionInpaintPipeline,
          FlaxStableDiffusionPipeline,
      )

try:
      if not (is_note_seq_available()):
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      from .utils.dummy_note_seq_objects import *  # noqa F403
else:
      from .pipelines import MidiProcessor