'''simple docstring'''




import shutil
import tempfile
import unittest

from transformers import (
    SPIECE_UNDERLINE,
    AddedToken,
    BatchEncoding,
    NllbTokenizer,
    NllbTokenizerFast,
    is_torch_available,
)
from transformers.testing_utils import (
    get_tests_dir,
    nested_simplify,
    require_sentencepiece,
    require_tokenizers,
    require_torch,
)

from ...test_tokenization_common import TokenizerTesterMixin


__SCREAMING_SNAKE_CASE			:	int	=    get_tests_dir("""fixtures/test_sentencepiece.model""")


if is_torch_available():
  from transformers.models.mam_aaa.modeling_mam_aaa import shift_tokens_right

__SCREAMING_SNAKE_CASE			:	str	=    256_047
__SCREAMING_SNAKE_CASE			:	Union[str, Any]	=    256_145

@require_sentencepiece
@require_tokenizers
class       lowerCamelCase_      (lowercase_				,					unittest.TestCase       ):
      '''simple docstring'''

      __UpperCamelCase:    Union[str, Any]         =		NllbTokenizer
      __UpperCamelCase:    Optional[Any]         =		NllbTokenizerFast
      __UpperCamelCase:    str         =		True
      __UpperCamelCase:    Any         =		True
      __UpperCamelCase:    Dict         =		{}




      def 	_A      (			self		:							Dict			):
             super().setUp()

             # We have a SentencePiece fixture for testing
             _UpperCAmelCase	:    List[Any]				 =       NllbTokenizer(lowerCamelCase_		,   keep_accents=lowerCamelCase_			)
             tokenizer.save_pretrained(self.tmpdirname			)




      def 	_A      (			self		:							Union[str, Any]			):
             _UpperCAmelCase	:    List[Any]				 =       NllbTokenizer(lowerCamelCase_		,   keep_accents=lowerCamelCase_			)

             _UpperCAmelCase	:    Optional[int]				 =       tokenizer.tokenize("This is a test"			)
             self.assertListEqual(lowerCamelCase_		,   ["▁This", "▁is", "▁a", "▁t", "est"]			)

             self.assertListEqual(
                 tokenizer.convert_tokens_to_ids(lowerCamelCase_			)		,   [value + tokenizer.fairseq_offset for value in [285, 46, 10, 170, 382]]		,   )

             _UpperCAmelCase	:    Tuple				 =       tokenizer.tokenize("I was born in 92000, and this is falsé."			)
             self.assertListEqual(
                 lowerCamelCase_		,   [
                     SPIECE_UNDERLINE + "I",
                     SPIECE_UNDERLINE + "was",
                     SPIECE_UNDERLINE + "b",
                     "or",
                     "n",
                     SPIECE_UNDERLINE + "in",
                     SPIECE_UNDERLINE + "",
                     "9",
                     "2",
                     "0",
                     "0",
                     "0",
                     ",",
                     SPIECE_UNDERLINE + "and",
                     SPIECE_UNDERLINE + "this",
                     SPIECE_UNDERLINE + "is",
                     SPIECE_UNDERLINE + "f",
                     "al",
                     "s",
                     "é",
                     ".",
                 ]		,   )
             _UpperCAmelCase	:    Tuple				 =       tokenizer.convert_tokens_to_ids(lowerCamelCase_			)
             self.assertListEqual(
                 lowerCamelCase_		,   [
                     value + tokenizer.fairseq_offset
                     for value in [8, 21, 84, 55, 24, 19, 7, 2, 602, 347, 347, 347, 3, 12, 66, 46, 72, 80, 6, 2, 4]
                 ]		,   )

             _UpperCAmelCase	:    List[str]				 =       tokenizer.convert_ids_to_tokens(lowerCamelCase_			)
             self.assertListEqual(
                 lowerCamelCase_		,   [
                     SPIECE_UNDERLINE + "I",
                     SPIECE_UNDERLINE + "was",
                     SPIECE_UNDERLINE + "b",
                     "or",
                     "n",
                     SPIECE_UNDERLINE + "in",
                     SPIECE_UNDERLINE + "",
                     "<unk>",
                     "2",
                     "0",
                     "0",
                     "0",
                     ",",
                     SPIECE_UNDERLINE + "and",
                     SPIECE_UNDERLINE + "this",
                     SPIECE_UNDERLINE + "is",
                     SPIECE_UNDERLINE + "f",
                     "al",
                     "s",
                     "<unk>",
                     ".",
                 ]		,   )




      def 	_A      (			self		:							Tuple			):
             _UpperCAmelCase	:    str				 =       (self.rust_tokenizer_class, """hf-internal-testing/tiny-random-nllb""", {})
             for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
                    with self.subTest(F"""{tokenizer.__class__.__name__} ({pretrained_name})"""			):
                           _UpperCAmelCase	:    Any				 =       self.rust_tokenizer_class.from_pretrained(lowerCamelCase_		,   **lowerCamelCase_			)
                           _UpperCAmelCase	:    Any				 =       self.tokenizer_class.from_pretrained(lowerCamelCase_		,   **lowerCamelCase_			)

                           _UpperCAmelCase	:    Optional[Any]				 =       tempfile.mkdtemp()

                           _UpperCAmelCase	:    List[str]				 =       tokenizer_r.save_pretrained(lowerCamelCase_			)
                           _UpperCAmelCase	:    Optional[Any]				 =       tokenizer_p.save_pretrained(lowerCamelCase_			)

                           # Checks it save with the same files + the tokenizer.json file for the fast one
                           self.assertTrue(any("tokenizer.json" in f for f in tokenizer_r_files			)			)
                           _UpperCAmelCase	:    Optional[Any]				 =       tuple(f for f in tokenizer_r_files if "tokenizer.json" not in f			)
                           self.assertSequenceEqual(lowerCamelCase_		,   lowerCamelCase_			)

                           # Checks everything loads correctly in the same way
                           _UpperCAmelCase	:    Any				 =       tokenizer_r.from_pretrained(lowerCamelCase_			)
                           _UpperCAmelCase	:    Any				 =       tokenizer_p.from_pretrained(lowerCamelCase_			)

                           # Check special tokens are set accordingly on Rust and Python
                           for key in tokenizer_pp.special_tokens_map:
                                  self.assertTrue(hasattr(lowerCamelCase_		,   lowerCamelCase_			)			)

                           shutil.rmtree(lowerCamelCase_			)

                           # Save tokenizer rust, legacy_format=True
                           _UpperCAmelCase	:    Union[str, Any]				 =       tempfile.mkdtemp()

                           _UpperCAmelCase	:    str				 =       tokenizer_r.save_pretrained(lowerCamelCase_		,   legacy_format=lowerCamelCase_			)
                           _UpperCAmelCase	:    int				 =       tokenizer_p.save_pretrained(lowerCamelCase_			)

                           # Checks it save with the same files
                           self.assertSequenceEqual(lowerCamelCase_		,   lowerCamelCase_			)

                           # Checks everything loads correctly in the same way
                           _UpperCAmelCase	:    Optional[Any]				 =       tokenizer_r.from_pretrained(lowerCamelCase_			)
                           _UpperCAmelCase	:    List[Any]				 =       tokenizer_p.from_pretrained(lowerCamelCase_			)

                           # Check special tokens are set accordingly on Rust and Python
                           for key in tokenizer_pp.special_tokens_map:
                                  self.assertTrue(hasattr(lowerCamelCase_		,   lowerCamelCase_			)			)

                           shutil.rmtree(lowerCamelCase_			)

                           # Save tokenizer rust, legacy_format=False
                           _UpperCAmelCase	:    str				 =       tempfile.mkdtemp()

                           _UpperCAmelCase	:    Any				 =       tokenizer_r.save_pretrained(lowerCamelCase_		,   legacy_format=lowerCamelCase_			)
                           _UpperCAmelCase	:    List[str]				 =       tokenizer_p.save_pretrained(lowerCamelCase_			)

                           # Checks it saved the tokenizer.json file
                           self.assertTrue(any("tokenizer.json" in f for f in tokenizer_r_files			)			)

                           # Checks everything loads correctly in the same way
                           _UpperCAmelCase	:    List[str]				 =       tokenizer_r.from_pretrained(lowerCamelCase_			)
                           _UpperCAmelCase	:    List[str]				 =       tokenizer_p.from_pretrained(lowerCamelCase_			)

                           # Check special tokens are set accordingly on Rust and Python
                           for key in tokenizer_pp.special_tokens_map:
                                  self.assertTrue(hasattr(lowerCamelCase_		,   lowerCamelCase_			)			)

                           shutil.rmtree(lowerCamelCase_			)




      @require_torch
      def 	_A      (			self		:							Dict			):



             if not self.test_seqaseq:
                    return

             _UpperCAmelCase	:    Any				 =       self.get_tokenizers()
             for tokenizer in tokenizers:
                    with self.subTest(F"""{tokenizer.__class__.__name__}"""			):
                           # Longer text that will definitely require truncation.
                           _UpperCAmelCase	:    List[str]				 =       [
                               """ UN Chief Says There Is No Military Solution in Syria""",
                               """ Secretary-General Ban Ki-moon says his response to Russia's stepped up military support for"""
                               """ Syria is that 'there is no military solution' to the nearly five-year conflict and more weapons"""
                               """ will only worsen the violence and misery for millions of people.""",
                           ]
                           _UpperCAmelCase	:    List[Any]				 =       [
                               """Şeful ONU declară că nu există o soluţie militară în Siria""",
                               """Secretarul General Ban Ki-moon declară că răspunsul său la intensificarea sprijinului militar al"""
                               """ Rusiei pentru Siria este că \"nu există o soluţie militară\" la conflictul de aproape cinci ani şi"""
                               """ că noi arme nu vor face decât să înrăutăţească violenţele şi mizeria pentru milioane de oameni.""",
                           ]
                           try:
                                  _UpperCAmelCase	:    Union[str, Any]				 =       tokenizer.prepare_seqaseq_batch(
                                      src_texts=lowerCamelCase_		,   tgt_texts=lowerCamelCase_		,   max_length=3		,   max_target_length=10		,   return_tensors="pt"		,   src_lang="eng_Latn"		,   tgt_lang="ron_Latn"		,   )
                           except NotImplementedError:
                                  return
                           self.assertEqual(batch.input_ids.shape[1]		,   3			)
                           self.assertEqual(batch.labels.shape[1]		,   10			)
                           # max_target_length will default to max_length if not specified
                           _UpperCAmelCase	:    Optional[int]				 =       tokenizer.prepare_seqaseq_batch(
                               lowerCamelCase_		,   tgt_texts=lowerCamelCase_		,   max_length=3		,   return_tensors="pt"			)
                           self.assertEqual(batch.input_ids.shape[1]		,   3			)
                           self.assertEqual(batch.labels.shape[1]		,   3			)

                           _UpperCAmelCase	:    int				 =       tokenizer.prepare_seqaseq_batch(
                               src_texts=lowerCamelCase_		,   max_length=3		,   max_target_length=10		,   return_tensors="pt"			)
                           self.assertEqual(batch_encoder_only.input_ids.shape[1]		,   3			)
                           self.assertEqual(batch_encoder_only.attention_mask.shape[1]		,   3			)
                           self.assertNotIn("decoder_input_ids"		,   lowerCamelCase_			)




      @unittest.skip("Unfortunately way too slow to build a BPE with SentencePiece."			)
      def 	_A      (			self		:							Optional[Any]			):
             pass





      def 	_A      (			self		:							Optional[int]			):



             for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
                    with self.subTest(F"""{tokenizer.__class__.__name__} ({pretrained_name})"""			):
                           _UpperCAmelCase	:    List[str]				 =       [AddedToken("<special>"		,   lstrip=lowerCamelCase_			)]

                           _UpperCAmelCase	:    Optional[Any]				 =       self.rust_tokenizer_class.from_pretrained(
                               lowerCamelCase_		,   additional_special_tokens=lowerCamelCase_		,   **lowerCamelCase_			)
                           _UpperCAmelCase	:    Union[str, Any]				 =       tokenizer_r.encode("Hey this is a <special> token"			)

                           _UpperCAmelCase	:    Tuple				 =       tokenizer_r.encode("<special>"		,   add_special_tokens=lowerCamelCase_			)[0]

                           self.assertTrue(special_token_id in r_output			)

                           if self.test_slow_tokenizer:
                                  _UpperCAmelCase	:    Optional[int]				 =       self.rust_tokenizer_class.from_pretrained(
                                      lowerCamelCase_		,   additional_special_tokens=lowerCamelCase_		,   **lowerCamelCase_		,   )
                                  _UpperCAmelCase	:    Optional[Any]				 =       self.tokenizer_class.from_pretrained(
                                      lowerCamelCase_		,   additional_special_tokens=lowerCamelCase_		,   **lowerCamelCase_			)

                                  _UpperCAmelCase	:    str				 =       tokenizer_p.encode("Hey this is a <special> token"			)

                                  _UpperCAmelCase	:    Union[str, Any]				 =       tokenizer_cr.encode("Hey this is a <special> token"			)

                                  self.assertEqual(lowerCamelCase_		,   lowerCamelCase_			)
                                  self.assertEqual(lowerCamelCase_		,   lowerCamelCase_			)
                                  self.assertTrue(special_token_id in p_output			)
                                  self.assertTrue(special_token_id in cr_output			)

@require_torch
@require_sentencepiece
@require_tokenizers
class       lowerCamelCase_      (unittest.TestCase       ):
      '''simple docstring'''

      __UpperCamelCase:    Tuple         =		"facebook/nllb-200-distilled-600M"
      __UpperCamelCase:    int         =		[
          " UN Chief Says There Is No Military Solution in Syria",
          " Secretary-General Ban Ki-moon says his response to Russia\'s stepped up military support for Syria is that \"there is no military solution\" to the nearly five-year conflict and more weapons will only worsen the violence and misery for millions of people.",
      ]
      __UpperCamelCase:    Dict         =		[
          "Şeful ONU declară că nu există o soluţie militară în Siria",
          "Secretarul General Ban Ki-moon declară că răspunsul său la intensificarea sprijinului militar al Rusiei"
          " pentru Siria este că \"nu există o soluţie militară\" la conflictul de aproape cinci ani şi că noi arme nu vor"
          " face decât să înrăutăţească violenţele şi mizeria pentru milioane de oameni.",
      ]
      __UpperCamelCase:    Optional[int]         =		[
          2_5_6_0_4_7,
          1_6_2_9_7,
          1_3_4_4_0_8,
          8_1_6_5,
          2_4_8_0_6_6,
          1_4_7_3_4,
          9_5_0,
          1_1_3_5,
          1_0_5_7_2_1,
          3_5_7_3,
          8_3,
          2_7_3_5_2,
          1_0_8,
          4_9_4_8_6,
          2,
      ]




      @classmethod
      def 	_A      (			cls		:							Optional[Any]			):
             _UpperCAmelCase	:    NllbTokenizer				 =       NllbTokenizer.from_pretrained(
                 cls.checkpoint_name		,   src_lang="eng_Latn"		,   tgt_lang="ron_Latn"			)
             _UpperCAmelCase	:    List[str]				 =       1
             return cls




      def 	_A      (			self		:							List[str]			):
             self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["ace_Arab"]		,   256001			)
             self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["ace_Latn"]		,   256002			)
             self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["fra_Latn"]		,   256057			)




      def 	_A      (			self		:							List[str]			):
             _UpperCAmelCase	:    List[Any]				 =       self.tokenizer.batch_encode_plus(self.src_text			).input_ids[0]
             self.assertListEqual(self.expected_src_tokens		,   lowerCamelCase_			)




      def 	_A      (			self		:							Union[str, Any]			):
             self.assertIn(lowerCamelCase_		,   self.tokenizer.all_special_ids			)
             # fmt: off
             _UpperCAmelCase	:    Union[str, Any]				 =       [RO_CODE, 4254, 98068, 112923, 39072, 3909, 713, 102767, 26, 17314, 35642, 14683, 33118, 2022, 66987, 2, 256047]
             # fmt: on

             _UpperCAmelCase	:    Optional[int]				 =       self.tokenizer.decode(lowerCamelCase_		,   skip_special_tokens=lowerCamelCase_			)
             _UpperCAmelCase	:    Optional[int]				 =       self.tokenizer.decode(generated_ids[1:]		,   skip_special_tokens=lowerCamelCase_			)
             self.assertEqual(lowerCamelCase_		,   lowerCamelCase_			)
             self.assertNotIn(self.tokenizer.eos_token		,   lowerCamelCase_			)




      def 	_A      (			self		:							int			):
             _UpperCAmelCase	:    Dict				 =       ["""this is gunna be a long sentence """ * 20]
             assert isinstance(src_text[0]		,   lowerCamelCase_			)
             _UpperCAmelCase	:    str				 =       10
             _UpperCAmelCase	:    List[str]				 =       self.tokenizer(lowerCamelCase_		,   max_length=lowerCamelCase_		,   truncation=lowerCamelCase_			).input_ids[0]
             self.assertEqual(ids[-1]		,   2			)
             self.assertEqual(ids[0]		,   lowerCamelCase_			)
             self.assertEqual(len(lowerCamelCase_			)		,   lowerCamelCase_			)




      def 	_A      (			self		:							List[str]			):
             self.assertListEqual(self.tokenizer.convert_tokens_to_ids(["<mask>", "ar_AR"]			)		,   [256203, 3]			)




      def 	_A      (			self		:							Any			):
             _UpperCAmelCase	:    Tuple				 =       tempfile.mkdtemp()
             _UpperCAmelCase	:    Union[str, Any]				 =       self.tokenizer.fairseq_tokens_to_ids
             self.tokenizer.save_pretrained(lowerCamelCase_			)
             _UpperCAmelCase	:    Optional[Any]				 =       NllbTokenizer.from_pretrained(lowerCamelCase_			)
             self.assertDictEqual(new_tok.fairseq_tokens_to_ids		,   lowerCamelCase_			)




      @require_torch
      def 	_A      (			self		:							Union[str, Any]			):
             _UpperCAmelCase	:    int				 =       self.tokenizer(
                 self.src_text		,   text_target=self.tgt_text		,   padding=lowerCamelCase_		,   truncation=lowerCamelCase_		,   max_length=len(self.expected_src_tokens			)		,   return_tensors="pt"		,   )
             _UpperCAmelCase	:    Tuple				 =       shift_tokens_right(
                 batch["labels"]		,   self.tokenizer.pad_token_id		,   self.tokenizer.lang_code_to_id["ron_Latn"]			)

             self.assertIsInstance(lowerCamelCase_		,   lowerCamelCase_			)

             self.assertEqual((2, 15)		,   batch.input_ids.shape			)
             self.assertEqual((2, 15)		,   batch.attention_mask.shape			)
             _UpperCAmelCase	:    List[str]				 =       batch.input_ids.tolist()[0]
             self.assertListEqual(self.expected_src_tokens		,   lowerCamelCase_			)
             self.assertEqual(lowerCamelCase_		,   batch.decoder_input_ids[0, 0]			)  # EOS
             # Test that special tokens are reset
             self.assertEqual(self.tokenizer.prefix_tokens		,   [EN_CODE]			)
             self.assertEqual(self.tokenizer.suffix_tokens		,   [self.tokenizer.eos_token_id]			)




      def 	_A      (			self		:							Any			):
             _UpperCAmelCase	:    Any				 =       self.tokenizer(self.src_text		,   padding=lowerCamelCase_		,   truncation=lowerCamelCase_		,   max_length=3		,   return_tensors="pt"			)
             _UpperCAmelCase	:    str				 =       self.tokenizer(
                 text_target=self.tgt_text		,   padding=lowerCamelCase_		,   truncation=lowerCamelCase_		,   max_length=10		,   return_tensors="pt"			)
             _UpperCAmelCase	:    int				 =       targets["""input_ids"""]
             _UpperCAmelCase	:    List[Any]				 =       shift_tokens_right(
                 lowerCamelCase_		,   self.tokenizer.pad_token_id		,   decoder_start_token_id=self.tokenizer.lang_code_to_id[self.tokenizer.tgt_lang]		,   )

             self.assertEqual(batch.input_ids.shape[1]		,   3			)
             self.assertEqual(batch.decoder_input_ids.shape[1]		,   10			)




      @require_torch
      def 	_A      (			self		:							Optional[Any]			):
             _UpperCAmelCase	:    Optional[int]				 =       self.tokenizer._build_translation_inputs(
                 "A test"		,   return_tensors="pt"		,   src_lang="eng_Latn"		,   tgt_lang="fra_Latn"			)

             self.assertEqual(
                 nested_simplify(lowerCamelCase_			)		,   {
                     # A, test, EOS, en_XX
                     "input_ids": [[256047, 70, 7356, 2]],
                     "attention_mask": [[1, 1, 1, 1]],
                     # ar_AR
                     "forced_bos_token_id": 256057,
                 }		,   )





      @require_torch
      def 	_A      (			self		:							Dict			):
             _UpperCAmelCase	:    Optional[Any]				 =       True
             _UpperCAmelCase	:    int				 =       self.tokenizer(
                 "UN Chief says there is no military solution in Syria"		,   src_lang="eng_Latn"		,   tgt_lang="fra_Latn"			)
             self.assertEqual(
                 inputs.input_ids		,   [16297, 134408, 25653, 6370, 248, 254, 103929, 94995, 108, 49486, 2, 256047]			)

             _UpperCAmelCase	:    List[str]				 =       False
             _UpperCAmelCase	:    str				 =       self.tokenizer(
                 "UN Chief says there is no military solution in Syria"		,   src_lang="eng_Latn"		,   tgt_lang="fra_Latn"			)
             self.assertEqual(
                 inputs.input_ids		,   [256047, 16297, 134408, 25653, 6370, 248, 254, 103929, 94995, 108, 49486, 2]			)








'''simple docstring'''




__UpperCAmelCase            =       """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



