

import os
import sys
import warnings
from dataclasses import dataclass, field
from io import BytesIO
from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Optional, Union

import numpy as np
import pyarrow as pa

from .. import config
from ..download.streaming_download_manager import xopen
from ..table import array_cast
from ..utils.file_utils import is_local_path
from ..utils.py_utils import first_non_null_value, no_op_if_value_is_null, string_to_dict


if TYPE_CHECKING:
			import PIL.Image

			from .features import FeatureType


a__				=		None
a__				=		'''<''' if sys.byteorder == '''little''' else '''>'''
# Origin: https://github.com/python-pillow/Pillow/blob/698951e19e19972aeed56df686868f1329981c12/src/PIL/Image.py#L3126 minus "|i1" which values are not preserved correctly when saving and loading an image
a__				=		[
    np.dtype('''|b1'''),
    np.dtype('''|u1'''),
    np.dtype('''<u2'''),
    np.dtype('''>u2'''),
    np.dtype('''<i2'''),
    np.dtype('''>i2'''),
    np.dtype('''<u4'''),
    np.dtype('''>u4'''),
    np.dtype('''<i4'''),
    np.dtype('''>i4'''),
    np.dtype('''<f4'''),
    np.dtype('''>f4'''),
    np.dtype('''<f8'''),
    np.dtype('''>f8'''),
]

@dataclass
class 				UpperCAmelCase_		:
							"""simple docstring"""







							UpperCAmelCase__       :						bool	    =    True
							UpperCAmelCase__       :						Optional[str]	    =    None
							# Automatically constructed
							UpperCAmelCase__       :						ClassVar[str]	    =    "PIL.Image.Image"
							UpperCAmelCase__       :						ClassVar[Any]	    =    pa.struct({"bytes": pa.binary(), "path": pa.string()}   )
							UpperCAmelCase__       :						str	    =    field(default="Image"				,       init=__lowercase				,       repr=__lowercase   )


							def __call__(			self       )    ->    str:
												return self.pa_type


							def 				__lowercase				(			self       ,							_a       )    ->    dict:
												if config.PIL_AVAILABLE:
																	import PIL.Image
												else:
																	raise ImportError('''To support encoding images, please install \'Pillow\'.'''       )

												if isinstance(_a       ,							_a       ):
																	_a	:    Dict         =		np.array(_a       )

												if isinstance(_a       ,							_a       ):
																	return {"path": value, "bytes": None}
												elif isinstance(_a       ,							_a       ):
																	return {"path": None, "bytes": value}
												elif isinstance(_a       ,							np.ndarray       ):
																	# convert the image array to PNG/TIFF bytes
																	return encode_np_array(_a       )
												elif isinstance(_a       ,							PIL.Image.Image       ):
																	# convert the PIL image to bytes (default format is PNG/TIFF)
																	return encode_pil_image(_a       )
												elif value.get('''path'''       ) is not None and os.path.isfile(value['''path''']       ):
																	# we set "bytes": None to not duplicate the data if they're already available locally
																	return {"bytes": None, "path": value.get('''path'''       )}
												elif value.get('''bytes'''       ) is not None or value.get('''path'''       ) is not None:
																	# store the image bytes, and path is used to infer the image format using the file extension
																	return {"bytes": value.get('''bytes'''       ), "path": value.get('''path'''       )}
												else:
																	raise ValueError(
																	    F"""An image sample should have one of 'path' or 'bytes' but they are missing or None in {value}."""       )


							def 				__lowercase				(			self       ,							_a       ,							_a=None       )    ->    "PIL.Image.Image":
												if not self.decode:
																	raise RuntimeError('''Decoding is disabled for this feature. Please use Image(decode=True) instead.'''       )

												if config.PIL_AVAILABLE:
																	import PIL.Image
												else:
																	raise ImportError('''To support decoding images, please install \'Pillow\'.'''       )

												if token_per_repo_id is None:
																	_a	:    int         =		{}

												_a      ,					_a	:    List[str]         =		value['''path'''], value['''bytes''']
												if bytes_ is None:
																	if path is None:
																						raise ValueError(F"""An image should have one of 'path' or 'bytes' but both are None in {value}."""       )
																	else:
																						if is_local_path(_a       ):
																											_a	:    Any         =		PIL.Image.open(_a       )
																						else:
																											_a	:    int         =		path.split('''::'''       )[-1]
																											try:
																																_a	:    Union[str, Any]         =		string_to_dict(_a       ,							config.HUB_DATASETS_URL       )['''repo_id''']
																																_a	:    List[Any]         =		token_per_repo_id.get(_a       )
																											except ValueError:
																																_a	:    Optional[Any]         =		None
																											with xopen(_a       ,							'''rb'''       ,							use_auth_token=_a       ) as f:
																																_a	:    Union[str, Any]         =		BytesIO(f.read()       )
																											_a	:    int         =		PIL.Image.open(bytes_       )
												else:
																	_a	:    int         =		PIL.Image.open(BytesIO(bytes_       )       )
												image.load()  # to avoid "Too many open files" errors
												return image


							def 				__lowercase				(			self       )    ->    Union["FeatureType", Dict[str, "FeatureType"]]:
												from .features import Value

												return (
												    self
												    if self.decode
												    else {
												        "bytes": Value('''binary'''       ),
												        "path": Value('''string'''       ),
												    }
												)


							def 				__lowercase				(			self       ,							_a       )    ->    pa.StructArray:
												if pa.types.is_string(storage.type       ):
																	_a	:    Tuple         =		pa.array([None] * len(_a       )       ,							type=pa.binary()       )
																	_a	:    Dict         =		pa.StructArray.from_arrays([bytes_array, storage]       ,							['''bytes''', '''path''']       ,							mask=storage.is_null()       )
												elif pa.types.is_binary(storage.type       ):
																	_a	:    Union[str, Any]         =		pa.array([None] * len(_a       )       ,							type=pa.string()       )
																	_a	:    Optional[Any]         =		pa.StructArray.from_arrays([storage, path_array]       ,							['''bytes''', '''path''']       ,							mask=storage.is_null()       )
												elif pa.types.is_struct(storage.type       ):
																	if storage.type.get_field_index('''bytes'''       ) >= 0:
																						_a	:    int         =		storage.field('''bytes'''       )
																	else:
																						_a	:    Any         =		pa.array([None] * len(_a       )       ,							type=pa.binary()       )
																	if storage.type.get_field_index('''path'''       ) >= 0:
																						_a	:    str         =		storage.field('''path'''       )
																	else:
																						_a	:    List[str]         =		pa.array([None] * len(_a       )       ,							type=pa.string()       )
																	_a	:    Dict         =		pa.StructArray.from_arrays([bytes_array, path_array]       ,							['''bytes''', '''path''']       ,							mask=storage.is_null()       )
												elif pa.types.is_list(storage.type       ):
																	_a	:    Union[str, Any]         =		pa.array(
																	    [encode_np_array(np.array(_a       )       )['''bytes'''] if arr is not None else None for arr in storage.to_pylist()]       ,							type=pa.binary()       ,							)
																	_a	:    Dict         =		pa.array([None] * len(_a       )       ,							type=pa.string()       )
																	_a	:    Dict         =		pa.StructArray.from_arrays(
																	    [bytes_array, path_array]       ,							['''bytes''', '''path''']       ,							mask=bytes_array.is_null()       )
												return array_cast(_a       ,							self.pa_type       )




							def 				__lowercase				(			self       ,							_a       )    ->    pa.StructArray:

												@no_op_if_value_is_null
												def path_to_bytes(_a       ):
																	with xopen(_a       ,							'''rb'''       ) as f:
																						_a	:    int         =		f.read()
																	return bytes_

												_a	:    int         =		pa.array(
												    [
												        (path_to_bytes(x['''path''']       ) if x['''bytes'''] is None else x['''bytes''']) if x is not None else None
												        for x in storage.to_pylist()
												    ]       ,							type=pa.binary()       ,							)
												_a	:    int         =		pa.array(
												    [os.path.basename(_a       ) if path is not None else None for path in storage.field('''path'''       ).to_pylist()]       ,							type=pa.string()       ,							)
												_a	:    List[str]         =		pa.StructArray.from_arrays([bytes_array, path_array]       ,							['''bytes''', '''path''']       ,							mask=bytes_array.is_null()       )
												return array_cast(_a       ,							self.pa_type       )



def    __UpperCAmelCase (	)			->     List[str]:

					"""simple docstring"""

					if config.PIL_AVAILABLE:
										import PIL.Image
					else:
										raise ImportError('''To support encoding images, please install \'Pillow\'.'''	)

					global _IMAGE_COMPRESSION_FORMATS
					if _IMAGE_COMPRESSION_FORMATS is None:
										PIL.Image.init()
										_a	:    Any         =		list(set(PIL.Image.OPEN.keys()	) & set(PIL.Image.SAVE.keys()	)	)
					return _IMAGE_COMPRESSION_FORMATS



def    __UpperCAmelCase (	__a      :			"PIL.Image.Image"	)			->     bytes:

					"""simple docstring"""

					_a	:    Tuple         =		BytesIO()
					if image.format in list_image_compression_formats():
										_a	:    Optional[Any]         =		image.format
					else:
										_a	:    Tuple         =		'''PNG''' if image.mode in ['''1''', '''L''', '''LA''', '''RGB''', '''RGBA'''] else '''TIFF'''
					image.save(__a		,format=__a	)
					return buffer.getvalue()



def    __UpperCAmelCase (	__a      :			"PIL.Image.Image"	)			->     dict:

					"""simple docstring"""

					if hasattr(__a		,'''filename'''	) and image.filename != "":
										return {"path": image.filename, "bytes": None}
					else:
										return {"path": None, "bytes": image_to_bytes(__a	)}



def    __UpperCAmelCase (	__a      :			np.ndarray	)			->     dict:

					"""simple docstring"""

					if config.PIL_AVAILABLE:
										import PIL.Image
					else:
										raise ImportError('''To support encoding images, please install \'Pillow\'.'''	)

					_a	:    str         =		array.dtype
					_a	:    Any         =		dtype.byteorder if dtype.byteorder != '''=''' else _NATIVE_BYTEORDER
					_a	:    Tuple         =		dtype.kind
					_a	:    List[str]         =		dtype.itemsize

					_a	:    Union[str, Any]         =		None

					# Multi-channel array case (only np.dtype("|u1") is allowed)
					if array.shape[2:]:
										_a	:    Optional[int]         =		np.dtype('''|u1'''	)
										if dtype_kind not in ["u", "i"]:
															raise TypeError(
															    F"""Unsupported array dtype {dtype} for image encoding. Only {dest_dtype} is supported for multi-channel arrays."""	)
										if dtype is not dest_dtype:
															warnings.warn(F"""Downcasting array dtype {dtype} to {dest_dtype} to be compatible with 'Pillow'"""	)
    # Exact match
					elif dtype in _VALID_IMAGE_ARRAY_DTPYES:
										_a	:    Any         =		dtype
					else:  # Downcast the type within the kind (np.can_cast(from_type, to_type, casting="same_kind") doesn't behave as expected, so do it manually)
										while dtype_itemsize >= 1:
															_a	:    List[str]         =		dtype_byteorder + dtype_kind + str(__a	)
															_a	:    int         =		np.dtype(__a	)
															if dest_dtype in _VALID_IMAGE_ARRAY_DTPYES:
																				warnings.warn(F"""Downcasting array dtype {dtype} to {dest_dtype} to be compatible with 'Pillow'"""	)
																				break
															else:
																				dtype_itemsize //= 2

					if dest_dtype is None:
										raise TypeError(
										    F"""Cannot convert dtype {dtype} to a valid image dtype. Valid image dtypes: {_VALID_IMAGE_ARRAY_DTPYES}"""	)
					_a	:    str         =		PIL.Image.fromarray(array.astype(__a	)	)
					return {"path": None, "bytes": image_to_bytes(__a	)}







def    __UpperCAmelCase (	__a      :			Union[List[str], List[dict], List[np.ndarray], List["PIL.Image.Image"]]	)			->     List[dict]:

					"""simple docstring"""

					if config.PIL_AVAILABLE:
										import PIL.Image
					else:
										raise ImportError('''To support encoding images, please install \'Pillow\'.'''	)

					if objs:
										_a      ,					_a	:    Dict         =		first_non_null_value(__a	)
										if isinstance(__a		,__a	):
															return [{"path": obj, "bytes": None} if obj is not None else None for obj in objs]
										if isinstance(__a		,np.ndarray	):
															_a	:    int         =		no_op_if_value_is_null(__a	)
															return [obj_to_image_dict_func(__a	) for obj in objs]
										elif isinstance(__a		,PIL.Image.Image	):
															_a	:    Optional[Any]         =		no_op_if_value_is_null(__a	)
															return [obj_to_image_dict_func(__a	) for obj in objs]
										else:
															return objs
					else:
										return objs






a__				=		'''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



