






'''simple docstring'''



import itertools
import json
import os
import unittest

from transformers import AddedToken, LongformerTokenizer, LongformerTokenizerFast
from transformers.models.longformer.tokenization_longformer import VOCAB_FILES_NAMES
from transformers.testing_utils import require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin
@require_tokenizers
class 							__SCREAMING_SNAKE_CASE       (							_lowerCAmelCase      ,      unittest.TestCase     ):
      __a  					=LongformerTokenizer
      __a  					=True
      __a  					=LongformerTokenizerFast
      __a  					=True




      def  __UpperCamelCase							(  self      )							->Optional[int]:



         '''simple docstring'''
         super().setUp()

         # Adapted from Sennrich et al. 2015 and https://github.com/rsennrich/subword-nmt
         __a				     =    [
             'l',
             'o',
             'w',
             'e',
             'r',
             's',
             't',
             'i',
             'd',
             'n',
             '\u0120',
             '\u0120l',
             '\u0120n',
             '\u0120lo',
             '\u0120low',
             'er',
             '\u0120lowest',
             '\u0120newer',
             '\u0120wider',
             '<unk>',
         ]
         __a				     =    dict(zip(lowerCamelCase ,   range(len(lowerCamelCase      )      )      )      )
         __a				     =    ['#version: 0.2', '\u0120 l', '\u0120l o', '\u0120lo w', 'e r', '']
         __a				     =    {'unk_token': '<unk>'}

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




      def  __UpperCamelCase							(  self ,   **lowerCamelCase      )							->Tuple:



         '''simple docstring'''
         kwargs.update(self.special_tokens_map      )
         return self.tokenizer_class.from_pretrained(self.tmpdirname ,   **lowerCamelCase      )




      def  __UpperCamelCase							(  self ,   **lowerCamelCase      )							->Union[str, Any]:



         '''simple docstring'''
         kwargs.update(self.special_tokens_map      )
         return self.rust_tokenizer_class.from_pretrained(self.tmpdirname ,   **lowerCamelCase      )




      def  __UpperCamelCase							(  self ,   lowerCamelCase      )							->Optional[int]:



         '''simple docstring'''
         __a				     =    'lower newer'
         __a				     =    'lower newer'
         return input_text, output_text




      def  __UpperCamelCase							(  self      )							->Optional[Any]:



         '''simple docstring'''
         __a				     =    self.tokenizer_class(self.vocab_file ,   self.merges_file ,   **self.special_tokens_map      )
         __a				     =    'lower newer'
         __a				     =    ['l', 'o', 'w', 'er', '\u0120', 'n', 'e', 'w', 'er']
         __a				     =    tokenizer.tokenize(lowerCamelCase      )  # , add_prefix_space=True)
         self.assertListEqual(lowerCamelCase ,   lowerCamelCase      )

         __a				     =    tokens + [tokenizer.unk_token]
         __a				     =    [0, 1, 2, 15, 10, 9, 3, 2, 15, 19]
         self.assertListEqual(tokenizer.convert_tokens_to_ids(lowerCamelCase      ) ,   lowerCamelCase      )




      def  __UpperCamelCase							(  self      )							->Tuple:



         '''simple docstring'''
         __a				     =    self.get_tokenizer()

         self.assertListEqual(tokenizer.encode('Hello world!' ,   add_special_tokens=lowerCamelCase      ) ,   [0, 3_1414, 232, 328, 2]      )
         self.assertListEqual(
             tokenizer.encode('Hello world! cécé herlolip 418' ,   add_special_tokens=lowerCamelCase      ) ,   [0, 3_1414, 232, 328, 740, 1140, 1_2695, 69, 4_6078, 1588, 2] ,   )




      @slow
      def  __UpperCamelCase							(  self      )							->Tuple:



         '''simple docstring'''
         __a				     =    self.tokenizer_class.from_pretrained('allenai/longformer-base-4096'      )

         __a				     =    tokenizer.encode('sequence builders' ,   add_special_tokens=lowerCamelCase      )
         __a				     =    tokenizer.encode('multi-sequence build' ,   add_special_tokens=lowerCamelCase      )

         __a				     =    tokenizer.encode(
             'sequence builders' ,   add_special_tokens=lowerCamelCase ,   add_prefix_space=lowerCamelCase      )
         __a				     =    tokenizer.encode(
             'sequence builders' ,   'multi-sequence build' ,   add_special_tokens=lowerCamelCase ,   add_prefix_space=lowerCamelCase      )

         __a				     =    tokenizer.build_inputs_with_special_tokens(lowerCamelCase      )
         __a				     =    tokenizer.build_inputs_with_special_tokens(lowerCamelCase ,   lowerCamelCase      )

         assert encoded_sentence == encoded_text_from_decode
         assert encoded_pair == encoded_pair_from_decode




      def  __UpperCamelCase							(  self      )							->Optional[Any]:



         '''simple docstring'''
         __a				     =    self.get_tokenizer()

         __a				     =    'Encode this sequence.'
         __a				     =    tokenizer.byte_encoder[' '.encode('utf-8'      )[0]]

         # Testing encoder arguments
         __a				     =    tokenizer.encode(lowerCamelCase ,   add_special_tokens=lowerCamelCase ,   add_prefix_space=lowerCamelCase      )
         __a				     =    tokenizer.convert_ids_to_tokens(encoded[0]      )[0]
         self.assertNotEqual(lowerCamelCase ,   lowerCamelCase      )

         __a				     =    tokenizer.encode(lowerCamelCase ,   add_special_tokens=lowerCamelCase ,   add_prefix_space=lowerCamelCase      )
         __a				     =    tokenizer.convert_ids_to_tokens(encoded[0]      )[0]
         self.assertEqual(lowerCamelCase ,   lowerCamelCase      )

         tokenizer.add_special_tokens({'bos_token': '<s>'}      )
         __a				     =    tokenizer.encode(lowerCamelCase ,   add_special_tokens=lowerCamelCase      )
         __a				     =    tokenizer.convert_ids_to_tokens(encoded[1]      )[0]
         self.assertNotEqual(lowerCamelCase ,   lowerCamelCase      )

         # Testing spaces after special tokens
         __a				     =    '<mask>'
         tokenizer.add_special_tokens(
             {'mask_token': AddedToken(lowerCamelCase ,   lstrip=lowerCamelCase ,   rstrip=lowerCamelCase      )}      )  # mask token has a left space
         __a				     =    tokenizer.convert_tokens_to_ids(lowerCamelCase      )

         __a				     =    'Encode <mask> sequence'
         __a				     =    'Encode <mask>sequence'

         __a				     =    tokenizer.encode(lowerCamelCase      )
         __a				     =    encoded.index(lowerCamelCase      )
         __a				     =    tokenizer.convert_ids_to_tokens(encoded[mask_loc + 1]      )[0]
         self.assertEqual(lowerCamelCase ,   lowerCamelCase      )

         __a				     =    tokenizer.encode(lowerCamelCase      )
         __a				     =    encoded.index(lowerCamelCase      )
         __a				     =    tokenizer.convert_ids_to_tokens(encoded[mask_loc + 1]      )[0]
         self.assertNotEqual(lowerCamelCase ,   lowerCamelCase      )




      def  __UpperCamelCase							(  self      )							->int:



         '''simple docstring'''
         pass




      def  __UpperCamelCase							(  self      )							->int:



         '''simple docstring'''
         for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
            with self.subTest(F"""{tokenizer.__class__.__name__} ({pretrained_name})"""      ):
               __a				     =    self.rust_tokenizer_class.from_pretrained(lowerCamelCase ,   **lowerCamelCase      )
               __a				     =    self.tokenizer_class.from_pretrained(lowerCamelCase ,   **lowerCamelCase      )
               __a				     =    'A, <mask> AllenNLP sentence.'
               __a				     =    tokenizer_r.encode_plus(lowerCamelCase ,   add_special_tokens=lowerCamelCase ,   return_token_type_ids=lowerCamelCase      )
               __a				     =    tokenizer_p.encode_plus(lowerCamelCase ,   add_special_tokens=lowerCamelCase ,   return_token_type_ids=lowerCamelCase      )

               # token_type_ids should put 0 everywhere
               self.assertEqual(sum(tokens_r['token_type_ids']      ) ,   sum(tokens_p['token_type_ids']      )      )

               # attention_mask should put 1 everywhere, so sum over length should be 1
               self.assertEqual(
                   sum(tokens_r['attention_mask']      ) / len(tokens_r['attention_mask']      ) ,   sum(tokens_p['attention_mask']      ) / len(tokens_p['attention_mask']      ) ,   )

               __a				     =    tokenizer_r.convert_ids_to_tokens(tokens_r['input_ids']      )
               __a				     =    tokenizer_p.convert_ids_to_tokens(tokens_p['input_ids']      )

               # Rust correctly handles the space before the mask while python doesnt
               self.assertSequenceEqual(tokens_p['input_ids'] ,   [0, 250, 6, 5_0264, 3823, 487, 2_1992, 3645, 4, 2]      )
               self.assertSequenceEqual(tokens_r['input_ids'] ,   [0, 250, 6, 5_0264, 3823, 487, 2_1992, 3645, 4, 2]      )

               self.assertSequenceEqual(
                   lowerCamelCase ,   ['<s>', 'A', ',', '<mask>', 'ĠAllen', 'N', 'LP', 'Ġsentence', '.', '</s>']      )
               self.assertSequenceEqual(
                   lowerCamelCase ,   ['<s>', 'A', ',', '<mask>', 'ĠAllen', 'N', 'LP', 'Ġsentence', '.', '</s>']      )




      def  __UpperCamelCase							(  self      )							->Any:



         '''simple docstring'''
         for trim_offsets, add_prefix_space in itertools.product([True, False] ,   repeat=2      ):
            __a				     =    self.rust_tokenizer_class.from_pretrained(
                self.tmpdirname ,   use_fast=lowerCamelCase ,   add_prefix_space=lowerCamelCase ,   trim_offsets=lowerCamelCase      )

            __a				     =    json.loads(tokenizer_r.backend_tokenizer.pre_tokenizer.__getstate__()      )
            __a				     =    json.loads(tokenizer_r.backend_tokenizer.post_processor.__getstate__()      )

            self.assertEqual(pre_tokenizer_state['add_prefix_space'] ,   lowerCamelCase      )

            self.assertEqual(post_processor_state['add_prefix_space'] ,   lowerCamelCase      )
            self.assertEqual(post_processor_state['trim_offsets'] ,   lowerCamelCase      )






      def  __UpperCamelCase							(  self      )							->Dict:



         '''simple docstring'''
         # Test which aims to verify that the offsets are well adapted to the argument `add_prefix_space` and
         # `trim_offsets`
         for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
            with self.subTest(F"""{tokenizer.__class__.__name__} ({pretrained_name})"""      ):
               __a				     =    'hello'  # `hello` is a token in the vocabulary of `pretrained_name`
               __a				     =    F"""{text_of_1_token} {text_of_1_token}"""

               __a				     =    self.rust_tokenizer_class.from_pretrained(
                   lowerCamelCase ,   use_fast=lowerCamelCase ,   add_prefix_space=lowerCamelCase ,   trim_offsets=lowerCamelCase      )
               __a				     =    tokenizer_r(lowerCamelCase ,   return_offsets_mapping=lowerCamelCase ,   add_special_tokens=lowerCamelCase      )
               self.assertEqual(encoding.offset_mapping[0] ,   (0, len(lowerCamelCase      ))      )
               self.assertEqual(
                   encoding.offset_mapping[1] ,   (len(lowerCamelCase      ) + 1, len(lowerCamelCase      ) + 1 + len(lowerCamelCase      )) ,   )

               __a				     =    self.rust_tokenizer_class.from_pretrained(
                   lowerCamelCase ,   use_fast=lowerCamelCase ,   add_prefix_space=lowerCamelCase ,   trim_offsets=lowerCamelCase      )
               __a				     =    tokenizer_r(lowerCamelCase ,   return_offsets_mapping=lowerCamelCase ,   add_special_tokens=lowerCamelCase      )
               self.assertEqual(encoding.offset_mapping[0] ,   (0, len(lowerCamelCase      ))      )
               self.assertEqual(
                   encoding.offset_mapping[1] ,   (len(lowerCamelCase      ) + 1, len(lowerCamelCase      ) + 1 + len(lowerCamelCase      )) ,   )

               __a				     =    self.rust_tokenizer_class.from_pretrained(
                   lowerCamelCase ,   use_fast=lowerCamelCase ,   add_prefix_space=lowerCamelCase ,   trim_offsets=lowerCamelCase      )
               __a				     =    tokenizer_r(lowerCamelCase ,   return_offsets_mapping=lowerCamelCase ,   add_special_tokens=lowerCamelCase      )
               self.assertEqual(encoding.offset_mapping[0] ,   (0, len(lowerCamelCase      ))      )
               self.assertEqual(
                   encoding.offset_mapping[1] ,   (len(lowerCamelCase      ), len(lowerCamelCase      ) + 1 + len(lowerCamelCase      )) ,   )

               __a				     =    self.rust_tokenizer_class.from_pretrained(
                   lowerCamelCase ,   use_fast=lowerCamelCase ,   add_prefix_space=lowerCamelCase ,   trim_offsets=lowerCamelCase      )
               __a				     =    tokenizer_r(lowerCamelCase ,   return_offsets_mapping=lowerCamelCase ,   add_special_tokens=lowerCamelCase      )
               self.assertEqual(encoding.offset_mapping[0] ,   (0, len(lowerCamelCase      ))      )
               self.assertEqual(
                   encoding.offset_mapping[1] ,   (len(lowerCamelCase      ), len(lowerCamelCase      ) + 1 + len(lowerCamelCase      )) ,   )

               __a				     =    F""" {text}"""

               # tokenizer_r = self.rust_tokenizer_class.from_pretrained(
               #     pretrained_name, use_fast=True, add_prefix_space=True, trim_offsets=True
               # )
               # encoding = tokenizer_r(text, return_offsets_mapping=True, add_special_tokens=False)
               # self.assertEqual(encoding.offset_mapping[0], (1, 1 + len(text_of_1_token)))
               # self.assertEqual(
               #     encoding.offset_mapping[1],
               #     (1 + len(text_of_1_token) + 1, 1 + len(text_of_1_token) + 1 + len(text_of_1_token)),
               # )

               __a				     =    self.rust_tokenizer_class.from_pretrained(
                   lowerCamelCase ,   use_fast=lowerCamelCase ,   add_prefix_space=lowerCamelCase ,   trim_offsets=lowerCamelCase      )
               __a				     =    tokenizer_r(lowerCamelCase ,   return_offsets_mapping=lowerCamelCase ,   add_special_tokens=lowerCamelCase      )
               self.assertEqual(encoding.offset_mapping[0] ,   (1, 1 + len(lowerCamelCase      ))      )
               self.assertEqual(
                   encoding.offset_mapping[1] ,   (1 + len(lowerCamelCase      ) + 1, 1 + len(lowerCamelCase      ) + 1 + len(lowerCamelCase      )) ,   )

               __a				     =    self.rust_tokenizer_class.from_pretrained(
                   lowerCamelCase ,   use_fast=lowerCamelCase ,   add_prefix_space=lowerCamelCase ,   trim_offsets=lowerCamelCase      )
               __a				     =    tokenizer_r(lowerCamelCase ,   return_offsets_mapping=lowerCamelCase ,   add_special_tokens=lowerCamelCase      )
               self.assertEqual(encoding.offset_mapping[0] ,   (0, 1 + len(lowerCamelCase      ))      )
               self.assertEqual(
                   encoding.offset_mapping[1] ,   (1 + len(lowerCamelCase      ), 1 + len(lowerCamelCase      ) + 1 + len(lowerCamelCase      )) ,   )

               __a				     =    self.rust_tokenizer_class.from_pretrained(
                   lowerCamelCase ,   use_fast=lowerCamelCase ,   add_prefix_space=lowerCamelCase ,   trim_offsets=lowerCamelCase      )
               __a				     =    tokenizer_r(lowerCamelCase ,   return_offsets_mapping=lowerCamelCase ,   add_special_tokens=lowerCamelCase      )
               self.assertEqual(encoding.offset_mapping[0] ,   (0, 1 + len(lowerCamelCase      ))      )
               self.assertEqual(
                   encoding.offset_mapping[1] ,   (1 + len(lowerCamelCase      ), 1 + len(lowerCamelCase      ) + 1 + len(lowerCamelCase      )) ,   )







'''simple docstring'''



__UpperCamelCase      :       Tuple      			=      """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