




'''simple docstring'''





from ..utils import (
    OptionalDependencyNotAvailable,
    is_flax_available,
    is_invisible_watermark_available,
    is_k_diffusion_available,
    is_librosa_available,
    is_note_seq_available,
    is_onnx_available,
    is_torch_available,
    is_transformers_available,
)


try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  from ..utils.dummy_pt_objects import *  # noqa F403
else:
  from .consistency_models import ConsistencyModelPipeline
  from .dance_diffusion import DanceDiffusionPipeline
  from .ddim import DDIMPipeline
  from .ddpm import DDPMPipeline
  from .dit import DiTPipeline
  from .latent_diffusion import LDMSuperResolutionPipeline
  from .latent_diffusion_uncond import LDMPipeline
  from .pipeline_utils import AudioPipelineOutput, DiffusionPipeline, ImagePipelineOutput
  from .pndm import PNDMPipeline
  from .repaint import RePaintPipeline
  from .score_sde_ve import ScoreSdeVePipeline
  from .stochastic_karras_ve import KarrasVePipeline

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 .audio_diffusion import AudioDiffusionPipeline, Mel

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 .alt_diffusion import AltDiffusionImgaImgPipeline, AltDiffusionPipeline
  from .audioldm import AudioLDMPipeline
  from .controlnet import (
      StableDiffusionControlNetImgaImgPipeline,
      StableDiffusionControlNetInpaintPipeline,
      StableDiffusionControlNetPipeline,
  )
  from .deepfloyd_if import (
      IFImgaImgPipeline,
      IFImgaImgSuperResolutionPipeline,
      IFInpaintingPipeline,
      IFInpaintingSuperResolutionPipeline,
      IFPipeline,
      IFSuperResolutionPipeline,
  )
  from .kandinsky import (
      KandinskyImgaImgPipeline,
      KandinskyInpaintPipeline,
      KandinskyPipeline,
      KandinskyPriorPipeline,
  )
  from .kandinskya_a import (
      KandinskyVaaControlnetImgaImgPipeline,
      KandinskyVaaControlnetPipeline,
      KandinskyVaaImgaImgPipeline,
      KandinskyVaaInpaintPipeline,
      KandinskyVaaPipeline,
      KandinskyVaaPriorEmbaEmbPipeline,
      KandinskyVaaPriorPipeline,
  )
  from .latent_diffusion import LDMTextToImagePipeline
  from .paint_by_example import PaintByExamplePipeline
  from .semantic_stable_diffusion import SemanticStableDiffusionPipeline
  from .shap_e import ShapEImgaImgPipeline, ShapEPipeline
  from .stable_diffusion import (
      CycleDiffusionPipeline,
      StableDiffusionAttendAndExcitePipeline,
      StableDiffusionDepthaImgPipeline,
      StableDiffusionDiffEditPipeline,
      StableDiffusionImageVariationPipeline,
      StableDiffusionImgaImgPipeline,
      StableDiffusionInpaintPipeline,
      StableDiffusionInpaintPipelineLegacy,
      StableDiffusionInstructPixaPixPipeline,
      StableDiffusionLatentUpscalePipeline,
      StableDiffusionLDMaDPipeline,
      StableDiffusionModelEditingPipeline,
      StableDiffusionPanoramaPipeline,
      StableDiffusionParadigmsPipeline,
      StableDiffusionPipeline,
      StableDiffusionPixaPixZeroPipeline,
      StableDiffusionSAGPipeline,
      StableDiffusionUpscalePipeline,
      StableUnCLIPImgaImgPipeline,
      StableUnCLIPPipeline,
  )
  from .stable_diffusion_safe import StableDiffusionPipelineSafe
  from .text_to_video_synthesis import TextToVideoSDPipeline, TextToVideoZeroPipeline, VideoToVideoSDPipeline
  from .unclip import UnCLIPImageVariationPipeline, UnCLIPPipeline
  from .unidiffuser import ImageTextPipelineOutput, UniDiffuserModel, UniDiffuserPipeline, UniDiffuserTextDecoder
  from .versatile_diffusion import (
      VersatileDiffusionDualGuidedPipeline,
      VersatileDiffusionImageVariationPipeline,
      VersatileDiffusionPipeline,
      VersatileDiffusionTextToImagePipeline,
  )
  from .vq_diffusion import 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 .stable_diffusion_xl import StableDiffusionXLImgaImgPipeline, StableDiffusionXLPipeline

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

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 .stable_diffusion import (
      OnnxStableDiffusionImgaImgPipeline,
      OnnxStableDiffusionInpaintPipeline,
      OnnxStableDiffusionInpaintPipelineLegacy,
      OnnxStableDiffusionPipeline,
      OnnxStableDiffusionUpscalePipeline,
      StableDiffusionOnnxPipeline,
  )

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 .stable_diffusion import StableDiffusionKDiffusionPipeline

try:
  if not is_flax_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  from ..utils.dummy_flax_objects import *  # noqa F403
else:
  from .pipeline_flax_utils import FlaxDiffusionPipeline


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 .controlnet import FlaxStableDiffusionControlNetPipeline
  from .stable_diffusion import (
      FlaxStableDiffusionImgaImgPipeline,
      FlaxStableDiffusionInpaintPipeline,
      FlaxStableDiffusionPipeline,
  )
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 .spectrogram_diffusion import MidiProcessor, SpectrogramDiffusionPipeline





import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
  import torch

if is_vision_available():
  from PIL import Image

  from transformers import ConvNextImageProcessor





class A__     (			unittest.TestCase			):



 """simple docstring"""







 def __init__(		self			:						Optional[Any]  ,    A_			:						Union[str, Any]  ,    A_			:						List[Any]=7  ,    A_			:						Optional[Any]=3  ,    A_			:						Optional[int]=1_8  ,    A_			:						Dict=3_0  ,    A_			:						Dict=4_0_0  ,    A_			:						List[Any]=True  ,    A_			:						int=None  ,    A_			:						List[Any]=0.875  ,    A_			:						List[str]=True  ,    A_			:						List[Any]=[0.5, 0.5, 0.5]  ,    A_			:						Optional[Any]=[0.5, 0.5, 0.5]  ,    ):






      '''simple docstring'''




      _lowerCAmelCase :       List[str]	   =     size if size is not None else {"shortest_edge": 2_0}
      _lowerCAmelCase :       Union[str, Any]	   =     parent
      _lowerCAmelCase :       int	   =     batch_size
      _lowerCAmelCase :       Any	   =     num_channels
      _lowerCAmelCase :       str	   =     image_size
      _lowerCAmelCase :       List[Any]	   =     min_resolution
      _lowerCAmelCase :       Tuple	   =     max_resolution
      _lowerCAmelCase :       Any	   =     do_resize
      _lowerCAmelCase :       List[str]	   =     size
      _lowerCAmelCase :       List[str]	   =     crop_pct
      _lowerCAmelCase :       Tuple	   =     do_normalize
      _lowerCAmelCase :       int	   =     image_mean
      _lowerCAmelCase :       Dict	   =     image_std


 def  __magic_name__							(		self			:						Dict							):






      '''simple docstring'''




      return {
          "image_mean": self.image_mean,
          "image_std": self.image_std,
          "do_normalize": self.do_normalize,
          "do_resize": self.do_resize,
          "size": self.size,
          "crop_pct": self.crop_pct,
      }





@require_torch
@require_vision
class A__     (			A	,		unittest.TestCase			):



 """simple docstring"""







 _lowercase  :       int  			=    ConvNextImageProcessor if is_vision_available() else None

 def  __magic_name__							(		self			:						Dict							):






      '''simple docstring'''




      _lowerCAmelCase :       int	   =     ConvNextImageProcessingTester(self							)

 @property
 def  __magic_name__							(		self			:						str							):






      '''simple docstring'''




      return self.image_processor_tester.prepare_image_processor_dict()

 def  __magic_name__							(		self			:						Union[str, Any]							):






      '''simple docstring'''




      _lowerCAmelCase :       int	   =     self.image_processing_class(**self.image_processor_dict							)
      self.assertTrue(hasattr(A_  ,    "do_resize"							)							)
      self.assertTrue(hasattr(A_  ,    "size"							)							)
      self.assertTrue(hasattr(A_  ,    "crop_pct"							)							)
      self.assertTrue(hasattr(A_  ,    "do_normalize"							)							)
      self.assertTrue(hasattr(A_  ,    "image_mean"							)							)
      self.assertTrue(hasattr(A_  ,    "image_std"							)							)

 def  __magic_name__							(		self			:						Optional[int]							):






      '''simple docstring'''




      _lowerCAmelCase :       str	   =     self.image_processing_class.from_dict(self.image_processor_dict							)
      self.assertEqual(image_processor.size  ,    {"shortest_edge": 2_0}							)

      _lowerCAmelCase :       Optional[int]	   =     self.image_processing_class.from_dict(self.image_processor_dict  ,    size=4_2							)
      self.assertEqual(image_processor.size  ,    {"shortest_edge": 4_2}							)

 def  __magic_name__							(		self			:						List[str]							):






      '''simple docstring'''




      pass

 def  __magic_name__							(		self			:						Tuple							):






      '''simple docstring'''




      _lowerCAmelCase :       Optional[int]	   =     self.image_processing_class(**self.image_processor_dict							)
      # create random PIL images
      _lowerCAmelCase :       Tuple	   =     prepare_image_inputs(self.image_processor_tester  ,    equal_resolution=A_							)
      for image in image_inputs:
           self.assertIsInstance(A_  ,    Image.Image							)

      # Test not batched input
      _lowerCAmelCase :       List[Any]	   =     image_processing(image_inputs[0]  ,    return_tensors="pt"							).pixel_values
      self.assertEqual(
          encoded_images.shape  ,    (
              1,
              self.image_processor_tester.num_channels,
              self.image_processor_tester.size["shortest_edge"],
              self.image_processor_tester.size["shortest_edge"],
          )  ,    )

      # Test batched
      _lowerCAmelCase :       Any	   =     image_processing(A_  ,    return_tensors="pt"							).pixel_values
      self.assertEqual(
          encoded_images.shape  ,    (
              self.image_processor_tester.batch_size,
              self.image_processor_tester.num_channels,
              self.image_processor_tester.size["shortest_edge"],
              self.image_processor_tester.size["shortest_edge"],
          )  ,    )

 def  __magic_name__							(		self			:						Optional[int]							):






      '''simple docstring'''




      _lowerCAmelCase :       Dict	   =     self.image_processing_class(**self.image_processor_dict							)
      # create random numpy tensors
      _lowerCAmelCase :       str	   =     prepare_image_inputs(self.image_processor_tester  ,    equal_resolution=A_  ,    numpify=A_							)
      for image in image_inputs:
           self.assertIsInstance(A_  ,    np.ndarray							)

      # Test not batched input
      _lowerCAmelCase :       str	   =     image_processing(image_inputs[0]  ,    return_tensors="pt"							).pixel_values
      self.assertEqual(
          encoded_images.shape  ,    (
              1,
              self.image_processor_tester.num_channels,
              self.image_processor_tester.size["shortest_edge"],
              self.image_processor_tester.size["shortest_edge"],
          )  ,    )

      # Test batched
      _lowerCAmelCase :       Optional[Any]	   =     image_processing(A_  ,    return_tensors="pt"							).pixel_values
      self.assertEqual(
          encoded_images.shape  ,    (
              self.image_processor_tester.batch_size,
              self.image_processor_tester.num_channels,
              self.image_processor_tester.size["shortest_edge"],
              self.image_processor_tester.size["shortest_edge"],
          )  ,    )


 def  __magic_name__							(		self			:						List[Any]							):






      '''simple docstring'''




      _lowerCAmelCase :       Tuple	   =     self.image_processing_class(**self.image_processor_dict							)
      # create random PyTorch tensors
      _lowerCAmelCase :       List[str]	   =     prepare_image_inputs(self.image_processor_tester  ,    equal_resolution=A_  ,    torchify=A_							)
      for image in image_inputs:
           self.assertIsInstance(A_  ,    torch.Tensor							)

      # Test not batched input
      _lowerCAmelCase :       Any	   =     image_processing(image_inputs[0]  ,    return_tensors="pt"							).pixel_values
      self.assertEqual(
          encoded_images.shape  ,    (
              1,
              self.image_processor_tester.num_channels,
              self.image_processor_tester.size["shortest_edge"],
              self.image_processor_tester.size["shortest_edge"],
          )  ,    )

      # Test batched
      _lowerCAmelCase :       Union[str, Any]	   =     image_processing(A_  ,    return_tensors="pt"							).pixel_values
      self.assertEqual(
          encoded_images.shape  ,    (
              self.image_processor_tester.batch_size,
              self.image_processor_tester.num_channels,
              self.image_processor_tester.size["shortest_edge"],
              self.image_processor_tester.size["shortest_edge"],
          )  ,    )






