
import copy
from typing import Any, Dict, List, Optional, Union

import numpy as np

from ...audio_utils import mel_filter_bank, spectrogram, window_function
from ...feature_extraction_sequence_utils import SequenceFeatureExtractor
from ...feature_extraction_utils import BatchFeature
from ...utils import TensorType, logging


A		: Union[str, Any]								=     logging.get_logger(__name__)



class    a_ (			_a    ):
			a	:			Any					   =							['''input_features''']






			def __init__(      self				,			__UpperCamelCase=80				,			__UpperCamelCase=16_000				,			__UpperCamelCase=160				,			__UpperCamelCase=30				,			__UpperCamelCase=400				,			__UpperCamelCase=0.0				,			__UpperCamelCase=False				,			**__UpperCamelCase				,			):
									super().__init__(
									    feature_size=__UpperCamelCase				,			sampling_rate=__UpperCamelCase				,			padding_value=__UpperCamelCase				,			return_attention_mask=__UpperCamelCase				,			**__UpperCamelCase				,			)
									_lowercase					       =					n_fft
									_lowercase					       =					hop_length
									_lowercase					       =					chunk_length
									_lowercase					       =					chunk_length * sampling_rate
									_lowercase					       =					self.n_samples // hop_length
									_lowercase					       =					sampling_rate
									_lowercase					       =					mel_filter_bank(
									    num_frequency_bins=1 + n_fft // 2				,			num_mel_filters=__UpperCamelCase				,			min_frequency=0.0				,			max_frequency=80_00.0				,			sampling_rate=__UpperCamelCase				,			norm="""slaney"""				,			mel_scale="""slaney"""				,			)






			def    UpperCamelCase_				(      self				,			__UpperCamelCase  ):
									_lowercase					       =					spectrogram(
									    __UpperCamelCase				,			window_function(self.n_fft				,			"""hann"""  )				,			frame_length=self.n_fft				,			hop_length=self.hop_length				,			power=2.0				,			mel_filters=self.mel_filters				,			log_mel="""log10"""				,			)
									_lowercase					       =					log_spec[:, :-1]
									_lowercase					       =					np.maximum(__UpperCamelCase				,			log_spec.max() - 8.0  )
									_lowercase					       =					(log_spec + 4.0) / 4.0
									return log_spec






			@staticmethod
			# Copied from transformers.models.wav2vec2.feature_extraction_wav2vec2.Wav2Vec2FeatureExtractor.zero_mean_unit_var_norm
			def    UpperCamelCase_				(      __UpperCamelCase				,			__UpperCamelCase				,			__UpperCamelCase = 0.0  ):
									if attention_mask is not None:
															_lowercase					       =					np.array(__UpperCamelCase				,			np.intaa  )
															_lowercase					       =					[]

															for vector, length in zip(__UpperCamelCase				,			attention_mask.sum(-1  )  ):
																					_lowercase					       =					(vector - vector[:length].mean()) / np.sqrt(vector[:length].var() + 1E-7  )
																					if length < normed_slice.shape[0]:
																											_lowercase					       =					padding_value

																					normed_input_values.append(__UpperCamelCase  )
									else:
															_lowercase					       =					[(x - x.mean()) / np.sqrt(x.var() + 1E-7  ) for x in input_values]

									return normed_input_values






			def __call__(      self				,			__UpperCamelCase				,			__UpperCamelCase = True				,			__UpperCamelCase = None				,			__UpperCamelCase = None				,			__UpperCamelCase = None				,			__UpperCamelCase = "max_length"				,			__UpperCamelCase = None				,			__UpperCamelCase = None				,			__UpperCamelCase = None				,			**__UpperCamelCase				,			):

									if sampling_rate is not None:
															if sampling_rate != self.sampling_rate:
																					raise ValueError(
																					    f"""The model corresponding to this feature extractor: {self.__class__.__name__} was trained using a"""
																					    f""" sampling rate of {self.sampling_rate}. Please make sure that the provided `raw_speech` input"""
																					    f""" was sampled with {self.sampling_rate} and not {sampling_rate}."""  )
									else:
															logger.warning(
															    """It is strongly recommended to pass the `sampling_rate` argument to this function. """
															    """Failing to do so can result in silent errors that might be hard to debug."""  )

									_lowercase					       =					isinstance(__UpperCamelCase				,			np.ndarray  ) and len(raw_speech.shape  ) > 1
									if is_batched_numpy and len(raw_speech.shape  ) > 2:
															raise ValueError(f"""Only mono-channel audio is supported for input to {self}"""  )
									_lowercase					       =					is_batched_numpy or (
									    isinstance(__UpperCamelCase				,			(list, tuple)  ) and (isinstance(raw_speech[0]				,			(np.ndarray, tuple, list)  ))
									)

									if is_batched:
															_lowercase					       =					[np.asarray([speech]				,			dtype=np.floataa  ).T for speech in raw_speech]
									elif not is_batched and not isinstance(__UpperCamelCase				,			np.ndarray  ):
															_lowercase					       =					np.asarray(__UpperCamelCase				,			dtype=np.floataa  )
									elif isinstance(__UpperCamelCase				,			np.ndarray  ) and raw_speech.dtype is np.dtype(np.floataa  ):
															_lowercase					       =					raw_speech.astype(np.floataa  )

									# always return batch
									if not is_batched:
															_lowercase					       =					[np.asarray([raw_speech]  ).T]

									_lowercase					       =					BatchFeature({"""input_features""": raw_speech}  )

									# convert into correct format for padding

									_lowercase					       =					self.pad(
									    __UpperCamelCase				,			padding=__UpperCamelCase				,			max_length=max_length if max_length else self.n_samples				,			truncation=__UpperCamelCase				,			pad_to_multiple_of=__UpperCamelCase				,			return_attention_mask=return_attention_mask or do_normalize				,			)

									# zero-mean and unit-variance normalization
									if do_normalize:
															_lowercase					       =					self.zero_mean_unit_var_norm(
															    padded_inputs["""input_features"""]				,			attention_mask=padded_inputs["""attention_mask"""]				,			padding_value=self.padding_value				,			)
															_lowercase					       =					np.stack(padded_inputs["""input_features"""]				,			axis=0  )

									# make sure list is in array format
									_lowercase					       =					padded_inputs.get("""input_features"""  ).transpose(2				,			0				,			1  )

									_lowercase					       =					[self._np_extract_fbank_features(__UpperCamelCase  ) for waveform in input_features[0]]

									if isinstance(input_features[0]				,			__UpperCamelCase  ):
															_lowercase					       =					[np.asarray(__UpperCamelCase				,			dtype=np.floataa  ) for feature in input_features]
									else:
															_lowercase					       =					input_features

									if return_attention_mask:
															# rescale from sample (48000) to feature (3000)
															_lowercase					       =					padded_inputs["""attention_mask"""][:, :: self.hop_length]

									if return_tensors is not None:
															_lowercase					       =					padded_inputs.convert_to_tensors(__UpperCamelCase  )

									return padded_inputs






			def    UpperCamelCase_				(      self  ):
									_lowercase					       =					copy.deepcopy(self.__dict__  )
									_lowercase					       =					self.__class__.__name__
									if "mel_filters" in output:
															del output["mel_filters"]
									return output

from dataclasses import dataclass
from typing import List, Optional, Union

import numpy as np
import PIL
from PIL import Image

from ...utils import (
    BaseOutput,
    OptionalDependencyNotAvailable,
    is_flax_available,
    is_k_diffusion_available,
    is_k_diffusion_version,
    is_onnx_available,
    is_torch_available,
    is_transformers_available,
    is_transformers_version,
)



@dataclass
class    a_ (			_a    ):
			a	:			Union[List[PIL.Image.Image], np.ndarray]
			a	:			Optional[List[bool]]


try:
		if not (is_transformers_available() and is_torch_available()):
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		from ...utils.dummy_torch_and_transformers_objects import *  # noqa F403
else:
		from .pipeline_cycle_diffusion import CycleDiffusionPipeline
		from .pipeline_stable_diffusion import StableDiffusionPipeline
		from .pipeline_stable_diffusion_attend_and_excite import StableDiffusionAttendAndExcitePipeline
		from .pipeline_stable_diffusion_imgaimg import StableDiffusionImgaImgPipeline
		from .pipeline_stable_diffusion_inpaint import StableDiffusionInpaintPipeline
		from .pipeline_stable_diffusion_inpaint_legacy import StableDiffusionInpaintPipelineLegacy
		from .pipeline_stable_diffusion_instruct_pixapix import StableDiffusionInstructPixaPixPipeline
		from .pipeline_stable_diffusion_latent_upscale import StableDiffusionLatentUpscalePipeline
		from .pipeline_stable_diffusion_ldmad import StableDiffusionLDMaDPipeline
		from .pipeline_stable_diffusion_model_editing import StableDiffusionModelEditingPipeline
		from .pipeline_stable_diffusion_panorama import StableDiffusionPanoramaPipeline
		from .pipeline_stable_diffusion_paradigms import StableDiffusionParadigmsPipeline
		from .pipeline_stable_diffusion_sag import StableDiffusionSAGPipeline
		from .pipeline_stable_diffusion_upscale import StableDiffusionUpscalePipeline
		from .pipeline_stable_unclip import StableUnCLIPPipeline
		from .pipeline_stable_unclip_imgaimg import StableUnCLIPImgaImgPipeline
		from .safety_checker import StableDiffusionSafetyChecker
		from .stable_unclip_image_normalizer import StableUnCLIPImageNormalizer

try:
		if not (is_transformers_available() and is_torch_available() and is_transformers_version('''>=''', '''4.25.0''')):
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		from ...utils.dummy_torch_and_transformers_objects import StableDiffusionImageVariationPipeline
else:
		from .pipeline_stable_diffusion_image_variation import StableDiffusionImageVariationPipeline


try:
		if not (is_transformers_available() and is_torch_available() and is_transformers_version('''>=''', '''4.26.0''')):
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		from ...utils.dummy_torch_and_transformers_objects import (
		    StableDiffusionDepthaImgPipeline,
		    StableDiffusionDiffEditPipeline,
		    StableDiffusionPixaPixZeroPipeline,
		)
else:
		from .pipeline_stable_diffusion_depthaimg import StableDiffusionDepthaImgPipeline
		from .pipeline_stable_diffusion_diffedit import StableDiffusionDiffEditPipeline
		from .pipeline_stable_diffusion_pixapix_zero import StableDiffusionPixaPixZeroPipeline


try:
		if not (
		    is_torch_available()
		    and is_transformers_available()
		    and is_k_diffusion_available()
		    and is_k_diffusion_version('''>=''', '''0.0.12''')
		):
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		from ...utils.dummy_torch_and_transformers_and_k_diffusion_objects import *  # noqa F403
else:
		from .pipeline_stable_diffusion_k_diffusion import StableDiffusionKDiffusionPipeline

try:
		if not (is_transformers_available() and is_onnx_available()):
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		from ...utils.dummy_onnx_objects import *  # noqa F403
else:
		from .pipeline_onnx_stable_diffusion import OnnxStableDiffusionPipeline, StableDiffusionOnnxPipeline
		from .pipeline_onnx_stable_diffusion_imgaimg import OnnxStableDiffusionImgaImgPipeline
		from .pipeline_onnx_stable_diffusion_inpaint import OnnxStableDiffusionInpaintPipeline
		from .pipeline_onnx_stable_diffusion_inpaint_legacy import OnnxStableDiffusionInpaintPipelineLegacy
		from .pipeline_onnx_stable_diffusion_upscale import OnnxStableDiffusionUpscalePipeline

if is_transformers_available() and is_flax_available():
		import flax



		@flax.struct.dataclass
		class    a_ (			_a    ):
					a	:			np.ndarray
					a	:			List[bool]







		from ...schedulers.scheduling_pndm_flax import PNDMSchedulerState
		from .pipeline_flax_stable_diffusion import FlaxStableDiffusionPipeline
		from .pipeline_flax_stable_diffusion_imgaimg import FlaxStableDiffusionImgaImgPipeline
		from .pipeline_flax_stable_diffusion_inpaint import FlaxStableDiffusionInpaintPipeline
		from .safety_checker_flax import FlaxStableDiffusionSafetyChecker