
'''simple docstring'''




lowercase			:				Optional[Any]    		=			'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






'''simple docstring'''




from typing import Dict, List, Optional, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import (
    center_crop,
    get_resize_output_image_size,
    normalize,
    rescale,
    resize,
    to_channel_dimension_format,
)
from ...image_utils import (
    IMAGENET_STANDARD_MEAN,
    IMAGENET_STANDARD_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_vision_available, logging


if is_vision_available():
      import PIL


lowercase			:				Optional[Any]    		=			logging.get_logger(__name__)





class  A				(							__snake_case						):
     __magic_name__						=		['''pixel_values''']





     def __init__(							self						,			SCREAMING_SNAKE_CASE = True						,			SCREAMING_SNAKE_CASE = None						,			SCREAMING_SNAKE_CASE = None						,			SCREAMING_SNAKE_CASE = PILImageResampling.BILINEAR						,			SCREAMING_SNAKE_CASE = True						,			SCREAMING_SNAKE_CASE = 1 / 255						,			SCREAMING_SNAKE_CASE = True						,			SCREAMING_SNAKE_CASE = None						,			SCREAMING_SNAKE_CASE = None						,			**SCREAMING_SNAKE_CASE						,			) ->				None:






         """simple docstring"""






         super().__init__(**SCREAMING_SNAKE_CASE	)
         A       :   str					=						size if size is not None else {'''shortest_edge''': 384}
         A       :   Tuple					=						get_size_dict(SCREAMING_SNAKE_CASE						,			default_to_square=SCREAMING_SNAKE_CASE	)

         A       :   str					=						do_resize
         A       :   List[Any]					=						size
         # Default value set here for backwards compatibility where the value in config is None
         A       :   List[Any]					=						crop_pct if crop_pct is not None else 224 / 256
         A       :   Optional[int]					=						resample
         A       :   Union[str, Any]					=						do_rescale
         A       :   List[str]					=						rescale_factor
         A       :   Union[str, Any]					=						do_normalize
         A       :   Any					=						image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
         A       :   Optional[int]					=						image_std if image_std is not None else IMAGENET_STANDARD_STD





     def 				__lowerCAmelCase							(							self						,			SCREAMING_SNAKE_CASE						,			SCREAMING_SNAKE_CASE						,			SCREAMING_SNAKE_CASE						,			SCREAMING_SNAKE_CASE = PILImageResampling.BICUBIC						,			SCREAMING_SNAKE_CASE = None						,			**SCREAMING_SNAKE_CASE						,			) ->				np.ndarray:






         """simple docstring"""






         A       :   str					=						get_size_dict(SCREAMING_SNAKE_CASE						,			default_to_square=SCREAMING_SNAKE_CASE	)
         if "shortest_edge" not in size:
             raise ValueError(F'Size dictionary must contain \'shortest_edge\' key. Got {size.keys()}'	)
         A       :   Any					=						size['''shortest_edge''']

         if shortest_edge < 384:
             # maintain same ratio, resizing shortest edge to shortest_edge/crop_pct
             A       :   Dict					=						int(shortest_edge / crop_pct	)
             A       :   str					=						get_resize_output_image_size(SCREAMING_SNAKE_CASE						,			size=SCREAMING_SNAKE_CASE						,			default_to_square=SCREAMING_SNAKE_CASE	)
             A       :   int					=						resize(image=SCREAMING_SNAKE_CASE						,			size=SCREAMING_SNAKE_CASE						,			resample=SCREAMING_SNAKE_CASE						,			data_format=SCREAMING_SNAKE_CASE						,			**SCREAMING_SNAKE_CASE	)
             # then crop to (shortest_edge, shortest_edge)
             return center_crop(image=SCREAMING_SNAKE_CASE						,			size=(shortest_edge, shortest_edge)						,			data_format=SCREAMING_SNAKE_CASE						,			**SCREAMING_SNAKE_CASE	)
         else:
             # warping (no cropping) when evaluated at 384 or larger
             return resize(
                 SCREAMING_SNAKE_CASE						,			size=(shortest_edge, shortest_edge)						,			resample=SCREAMING_SNAKE_CASE						,			data_format=SCREAMING_SNAKE_CASE						,			**SCREAMING_SNAKE_CASE	)





     def 				__lowerCAmelCase							(							self						,			SCREAMING_SNAKE_CASE						,			SCREAMING_SNAKE_CASE						,			SCREAMING_SNAKE_CASE = None						,			**SCREAMING_SNAKE_CASE						,			) ->				List[str]:






         """simple docstring"""






         return rescale(SCREAMING_SNAKE_CASE						,			scale=SCREAMING_SNAKE_CASE						,			data_format=SCREAMING_SNAKE_CASE						,			**SCREAMING_SNAKE_CASE	)





     def 				__lowerCAmelCase							(							self						,			SCREAMING_SNAKE_CASE						,			SCREAMING_SNAKE_CASE						,			SCREAMING_SNAKE_CASE						,			SCREAMING_SNAKE_CASE = None						,			**SCREAMING_SNAKE_CASE						,			) ->				np.ndarray:






         """simple docstring"""






         return normalize(SCREAMING_SNAKE_CASE						,			mean=SCREAMING_SNAKE_CASE						,			std=SCREAMING_SNAKE_CASE						,			data_format=SCREAMING_SNAKE_CASE						,			**SCREAMING_SNAKE_CASE	)





     def 				__lowerCAmelCase							(							self						,			SCREAMING_SNAKE_CASE						,			SCREAMING_SNAKE_CASE = None						,			SCREAMING_SNAKE_CASE = None						,			SCREAMING_SNAKE_CASE = None						,			SCREAMING_SNAKE_CASE = None						,			SCREAMING_SNAKE_CASE = None						,			SCREAMING_SNAKE_CASE = None						,			SCREAMING_SNAKE_CASE = None						,			SCREAMING_SNAKE_CASE = None						,			SCREAMING_SNAKE_CASE = None						,			SCREAMING_SNAKE_CASE = None						,			SCREAMING_SNAKE_CASE = ChannelDimension.FIRST						,			**SCREAMING_SNAKE_CASE						,			) ->				PIL.Image.Image:






         """simple docstring"""






         A       :   int					=						do_resize if do_resize is not None else self.do_resize
         A       :   Tuple					=						crop_pct if crop_pct is not None else self.crop_pct
         A       :   Optional[Any]					=						resample if resample is not None else self.resample
         A       :   List[Any]					=						do_rescale if do_rescale is not None else self.do_rescale
         A       :   List[Any]					=						rescale_factor if rescale_factor is not None else self.rescale_factor
         A       :   Union[str, Any]					=						do_normalize if do_normalize is not None else self.do_normalize
         A       :   Union[str, Any]					=						image_mean if image_mean is not None else self.image_mean
         A       :   List[str]					=						image_std if image_std is not None else self.image_std

         A       :   Union[str, Any]					=						size if size is not None else self.size
         A       :   List[Any]					=						get_size_dict(SCREAMING_SNAKE_CASE						,			default_to_square=SCREAMING_SNAKE_CASE	)

         A       :   Any					=						make_list_of_images(SCREAMING_SNAKE_CASE	)

         if not valid_images(SCREAMING_SNAKE_CASE	):
             raise ValueError(
                 '''Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, '''
                 '''torch.Tensor, tf.Tensor or jax.ndarray.'''	)

         if do_resize and size is None or resample is None:
             raise ValueError('''Size and resample must be specified if do_resize is True.'''	)

         if do_resize and size["shortest_edge"] < 384 and crop_pct is None:
             raise ValueError('''crop_pct must be specified if size < 384.'''	)

         if do_rescale and rescale_factor is None:
             raise ValueError('''Rescale factor must be specified if do_rescale is True.'''	)

         if do_normalize and (image_mean is None or image_std is None):
             raise ValueError('''Image mean and std must be specified if do_normalize is True.'''	)

         # All transformations expect numpy arrays.
         A       :   Optional[int]					=						[to_numpy_array(SCREAMING_SNAKE_CASE	) for image in images]

         if do_resize:
             A       :   Any					=						[self.resize(image=SCREAMING_SNAKE_CASE						,			size=SCREAMING_SNAKE_CASE						,			crop_pct=SCREAMING_SNAKE_CASE						,			resample=SCREAMING_SNAKE_CASE	) for image in images]

         if do_rescale:
             A       :   str					=						[self.rescale(image=SCREAMING_SNAKE_CASE						,			scale=SCREAMING_SNAKE_CASE	) for image in images]

         if do_normalize:
             A       :   Dict					=						[self.normalize(image=SCREAMING_SNAKE_CASE						,			mean=SCREAMING_SNAKE_CASE						,			std=SCREAMING_SNAKE_CASE	) for image in images]

         A       :   Any					=						[to_channel_dimension_format(SCREAMING_SNAKE_CASE						,			SCREAMING_SNAKE_CASE	) for image in images]

         A       :   Optional[int]					=						{'''pixel_values''': images}
         return BatchFeature(data=SCREAMING_SNAKE_CASE						,			tensor_type=SCREAMING_SNAKE_CASE	)




