



__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








import unittest

from transformers import (
    MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
    TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
    TextClassificationPipeline,
    pipeline,
)
from transformers.testing_utils import is_pipeline_test, nested_simplify, require_tf, require_torch, slow

from .test_pipelines_common import ANY


# These 2 model types require different inputs than those of the usual text models.
__UpperCAmelCase	       =	{'''LayoutLMv2Config''', '''LayoutLMv3Config'''}



@is_pipeline_test
class     lowerCAmelCase_		(  unittest.TestCase							):
       UpperCAmelCase__    : Dict       					=  MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING
       UpperCAmelCase__    : List[str]       					=  TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING

       if model_mapping is not None:
              UpperCAmelCase__    : Optional[Any]       					=  {config: model for config, model in model_mapping.items() if config.__name__ not in _TO_SKIP}
       if tf_model_mapping is not None:
              UpperCAmelCase__    : Dict       					=  {
                  config: model for config, model in tf_model_mapping.items() if config.__name__ not in _TO_SKIP
              }
       @require_torch
       def  snake_case_	(      self	)					->		int:
          UpperCamelCase   :  List[str]						     =     pipeline(
              task='text-classification',      model='hf-internal-testing/tiny-random-distilbert',      framework='pt'	)

          UpperCamelCase   :  str						     =     text_classifier('This is great !'	)
          self.assertEqual(nested_simplify(SCREAMING_SNAKE_CASE_	),      [{'label': 'LABEL_0', 'score': 0.5_04}]	)

          UpperCamelCase   :  Dict						     =     text_classifier('This is great !',      top_k=2	)
          self.assertEqual(
              nested_simplify(SCREAMING_SNAKE_CASE_	),      [{'label': 'LABEL_0', 'score': 0.5_04}, {'label': 'LABEL_1', 'score': 0.4_96}]	)

          UpperCamelCase   :  List[Any]						     =     text_classifier(['This is great !', 'This is bad'],      top_k=2	)
          self.assertEqual(
              nested_simplify(SCREAMING_SNAKE_CASE_	),      [
                  [{'label': 'LABEL_0', 'score': 0.5_04}, {'label': 'LABEL_1', 'score': 0.4_96}],
                  [{'label': 'LABEL_0', 'score': 0.5_04}, {'label': 'LABEL_1', 'score': 0.4_96}],
              ],      )

          UpperCamelCase   :  List[Any]						     =     text_classifier('This is great !',      top_k=1	)
          self.assertEqual(nested_simplify(SCREAMING_SNAKE_CASE_	),      [{'label': 'LABEL_0', 'score': 0.5_04}]	)

          # Legacy behavior
          UpperCamelCase   :  str						     =     text_classifier('This is great !',      return_all_scores=SCREAMING_SNAKE_CASE_	)
          self.assertEqual(nested_simplify(SCREAMING_SNAKE_CASE_	),      [{'label': 'LABEL_0', 'score': 0.5_04}]	)

          UpperCamelCase   :  Tuple						     =     text_classifier('This is great !',      return_all_scores=SCREAMING_SNAKE_CASE_	)
          self.assertEqual(
              nested_simplify(SCREAMING_SNAKE_CASE_	),      [[{'label': 'LABEL_0', 'score': 0.5_04}, {'label': 'LABEL_1', 'score': 0.4_96}]]	)

          UpperCamelCase   :  List[Any]						     =     text_classifier(['This is great !', 'Something else'],      return_all_scores=SCREAMING_SNAKE_CASE_	)
          self.assertEqual(
              nested_simplify(SCREAMING_SNAKE_CASE_	),      [
                  [{'label': 'LABEL_0', 'score': 0.5_04}, {'label': 'LABEL_1', 'score': 0.4_96}],
                  [{'label': 'LABEL_0', 'score': 0.5_04}, {'label': 'LABEL_1', 'score': 0.4_96}],
              ],      )

          UpperCamelCase   :  Optional[int]						     =     text_classifier(['This is great !', 'Something else'],      return_all_scores=SCREAMING_SNAKE_CASE_	)
          self.assertEqual(
              nested_simplify(SCREAMING_SNAKE_CASE_	),      [
                  {'label': 'LABEL_0', 'score': 0.5_04},
                  {'label': 'LABEL_0', 'score': 0.5_04},
              ],      )
       @require_torch
       def  snake_case_	(      self	)					->		Optional[Any]:
          import torch

          UpperCamelCase   :  str						     =     pipeline(
              task='text-classification',      model='hf-internal-testing/tiny-random-distilbert',      framework='pt',      device=torch.device('cpu'	),      )

          UpperCamelCase   :  List[Any]						     =     text_classifier('This is great !'	)
          self.assertEqual(nested_simplify(SCREAMING_SNAKE_CASE_	),      [{'label': 'LABEL_0', 'score': 0.5_04}]	)
       @require_tf
       def  snake_case_	(      self	)					->		Dict:
          UpperCamelCase   :  List[Any]						     =     pipeline(
              task='text-classification',      model='hf-internal-testing/tiny-random-distilbert',      framework='tf'	)

          UpperCamelCase   :  str						     =     text_classifier('This is great !'	)
          self.assertEqual(nested_simplify(SCREAMING_SNAKE_CASE_	),      [{'label': 'LABEL_0', 'score': 0.5_04}]	)
       @slow
       @require_torch
       def  snake_case_	(      self	)					->		int:
          UpperCamelCase   :  str						     =     pipeline('text-classification'	)

          UpperCamelCase   :  str						     =     text_classifier('This is great !'	)
          self.assertEqual(nested_simplify(SCREAMING_SNAKE_CASE_	),      [{'label': 'POSITIVE', 'score': 1.0}]	)
          UpperCamelCase   :  List[str]						     =     text_classifier('This is bad !'	)
          self.assertEqual(nested_simplify(SCREAMING_SNAKE_CASE_	),      [{'label': 'NEGATIVE', 'score': 1.0}]	)
          UpperCamelCase   :  int						     =     text_classifier('Birds are a type of animal'	)
          self.assertEqual(nested_simplify(SCREAMING_SNAKE_CASE_	),      [{'label': 'POSITIVE', 'score': 0.9_88}]	)
       @slow
       @require_tf
       def  snake_case_	(      self	)					->		Tuple:
          UpperCamelCase   :  int						     =     pipeline('text-classification',      framework='tf'	)

          UpperCamelCase   :  Tuple						     =     text_classifier('This is great !'	)
          self.assertEqual(nested_simplify(SCREAMING_SNAKE_CASE_	),      [{'label': 'POSITIVE', 'score': 1.0}]	)
          UpperCamelCase   :  Union[str, Any]						     =     text_classifier('This is bad !'	)
          self.assertEqual(nested_simplify(SCREAMING_SNAKE_CASE_	),      [{'label': 'NEGATIVE', 'score': 1.0}]	)
          UpperCamelCase   :  int						     =     text_classifier('Birds are a type of animal'	)
          self.assertEqual(nested_simplify(SCREAMING_SNAKE_CASE_	),      [{'label': 'POSITIVE', 'score': 0.9_88}]	)
       def  snake_case_	(      self,      SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_	)					->		Union[str, Any]:
          UpperCamelCase   :  str						     =     TextClassificationPipeline(model=SCREAMING_SNAKE_CASE_,      tokenizer=SCREAMING_SNAKE_CASE_	)
          return text_classifier, ["HuggingFace is in", "This is another test"]






       def  snake_case_	(      self,      SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_	)					->		Any:
          UpperCamelCase   :  List[str]						     =     text_classifier.model
          # Small inputs because BartTokenizer tiny has maximum position embeddings = 22
          UpperCamelCase   :  List[str]						     =     'HuggingFace is in'
          UpperCamelCase   :  Tuple						     =     text_classifier(SCREAMING_SNAKE_CASE_	)

          self.assertEqual(nested_simplify(SCREAMING_SNAKE_CASE_	),      [{'label': ANY(SCREAMING_SNAKE_CASE_	), 'score': ANY(SCREAMING_SNAKE_CASE_	)}]	)
          self.assertTrue(outputs[0]['label'] in model.config.idalabel.values()	)

          UpperCamelCase   :  List[Any]						     =     ['HuggingFace is in ', 'Paris is in France']
          UpperCamelCase   :  List[str]						     =     text_classifier(SCREAMING_SNAKE_CASE_	)
          self.assertEqual(
              nested_simplify(SCREAMING_SNAKE_CASE_	),      [{'label': ANY(SCREAMING_SNAKE_CASE_	), 'score': ANY(SCREAMING_SNAKE_CASE_	)}, {'label': ANY(SCREAMING_SNAKE_CASE_	), 'score': ANY(SCREAMING_SNAKE_CASE_	)}],      )
          self.assertTrue(outputs[0]['label'] in model.config.idalabel.values()	)
          self.assertTrue(outputs[1]['label'] in model.config.idalabel.values()	)

          # Forcing to get all results with `top_k=None`
          # This is NOT the legacy format
          UpperCamelCase   :  Optional[int]						     =     text_classifier(SCREAMING_SNAKE_CASE_,      top_k=SCREAMING_SNAKE_CASE_	)
          UpperCamelCase   :  str						     =     len(model.config.idalabel.values()	)
          self.assertEqual(
              nested_simplify(SCREAMING_SNAKE_CASE_	),      [[{'label': ANY(SCREAMING_SNAKE_CASE_	), 'score': ANY(SCREAMING_SNAKE_CASE_	)}] * N, [{'label': ANY(SCREAMING_SNAKE_CASE_	), 'score': ANY(SCREAMING_SNAKE_CASE_	)}] * N],      )

          UpperCamelCase   :  str						     =     {'text': 'HuggingFace is in ', 'text_pair': 'Paris is in France'}
          UpperCamelCase   :  Union[str, Any]						     =     text_classifier(SCREAMING_SNAKE_CASE_	)
          self.assertEqual(
              nested_simplify(SCREAMING_SNAKE_CASE_	),      {'label': ANY(SCREAMING_SNAKE_CASE_	), 'score': ANY(SCREAMING_SNAKE_CASE_	)},      )
          self.assertTrue(outputs['label'] in model.config.idalabel.values()	)

          # This might be used a text pair, but tokenizer + pipe interaction
          # makes it hard to understand that it's not using the pair properly
          # https://github.com/huggingface/transformers/issues/17305
          # We disabled this usage instead as it was outputting wrong outputs.
          UpperCamelCase   :  List[str]						     =     [['HuggingFace is in ', 'Paris is in France']]
          with self.assertRaises(SCREAMING_SNAKE_CASE_	):
             text_classifier(SCREAMING_SNAKE_CASE_	)

          # This used to be valid for doing text pairs
          # We're keeping it working because of backward compatibility
          UpperCamelCase   :  List[str]						     =     text_classifier([[['HuggingFace is in ', 'Paris is in France']]]	)
          self.assertEqual(
              nested_simplify(SCREAMING_SNAKE_CASE_	),      [{'label': ANY(SCREAMING_SNAKE_CASE_	), 'score': ANY(SCREAMING_SNAKE_CASE_	)}],      )
          self.assertTrue(outputs[0]['label'] in model.config.idalabel.values()	)



