






'''simple docstring'''




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

import numpy as np
import PIL
from PIL import Image

from ...utils import BaseOutput, is_torch_available, is_transformers_available

@dataclass
class      _UpperCAmelCase    (  lowerCAmelCase__		):
   snake_case					       =		{
       """sld_warmup_steps""": 15,
       """sld_guidance_scale""": 20,
       """sld_threshold""": 0.0,
       """sld_momentum_scale""": 0.0,
       """sld_mom_beta""": 0.0,
   }
   snake_case					       =		{
       """sld_warmup_steps""": 10,
       """sld_guidance_scale""": 10_00,
       """sld_threshold""": 0.01,
       """sld_momentum_scale""": 0.3,
       """sld_mom_beta""": 0.4,
   }
   snake_case					       =		{
       """sld_warmup_steps""": 7,
       """sld_guidance_scale""": 20_00,
       """sld_threshold""": 0.025,
       """sld_momentum_scale""": 0.5,
       """sld_mom_beta""": 0.7,
   }
   snake_case					       =		{
       """sld_warmup_steps""": 0,
       """sld_guidance_scale""": 50_00,
       """sld_threshold""": 1.0,
       """sld_momentum_scale""": 0.5,
       """sld_mom_beta""": 0.7,
   }





@dataclass
class      _UpperCAmelCase    (  lowerCAmelCase__		):
   snake_case					       =		42
   snake_case					       =		42
   snake_case					       =		42
   snake_case					       =		42


if is_transformers_available() and is_torch_available():
    from .pipeline_stable_diffusion_safe import StableDiffusionPipelineSafe
    from .safety_checker import SafeStableDiffusionSafetyChecker













'''simple docstring'''




from typing import List, Optional, Union

import numpy as np

from ...feature_extraction_sequence_utils import SequenceFeatureExtractor
from ...feature_extraction_utils import BatchFeature
from ...utils import PaddingStrategy, TensorType, logging


lowerCamelCase_							      =      logging.get_logger(__name__)

class      _UpperCAmelCase    (  snake_case_		):




   """simple docstring"""

   snake_case					       =		['''input_values''', '''attention_mask''']

   def __init__(	self				:			int   ,   __UpperCAmelCase				:			Optional[int]=1   ,   __UpperCAmelCase				:			List[str]=16000   ,   __UpperCAmelCase				:			Optional[Any]=0.0   ,   __UpperCAmelCase				:			Union[str, Any]=False   ,   __UpperCAmelCase				:			Dict=True   ,   **__UpperCAmelCase				:			int   ,   ):





         '''simple docstring'''





         super().__init__(feature_size=__UpperCAmelCase   ,   sampling_rate=__UpperCAmelCase   ,   padding_value=__UpperCAmelCase   ,   **__UpperCAmelCase	)
         _A      =			return_attention_mask
         _A      =			do_normalize

   @staticmethod
   def 		lowerCAmelCase				(	__UpperCAmelCase				:			List[np.ndarray]   ,   __UpperCAmelCase				:			List[np.ndarray]   ,   __UpperCAmelCase				:			float = 0.0	):





         '''simple docstring'''





         if attention_mask is not None:
               _A      =			np.array(__UpperCAmelCase   ,   np.intaa	)
               _A      =			[]

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

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

         return normed_input_values

   def __call__(	self				:			Dict   ,   __UpperCAmelCase				:			Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]]   ,   __UpperCAmelCase				:			Union[bool, str, PaddingStrategy] = False   ,   __UpperCAmelCase				:			Optional[int] = None   ,   __UpperCAmelCase				:			bool = False   ,   __UpperCAmelCase				:			Optional[int] = None   ,   __UpperCAmelCase				:			Optional[bool] = None   ,   __UpperCAmelCase				:			Optional[Union[str, TensorType]] = None   ,   __UpperCAmelCase				:			Optional[int] = None   ,   **__UpperCAmelCase				:			str   ,   ):





         '''simple docstring'''





         if sampling_rate is not None:
               if sampling_rate != self.sampling_rate:
                     raise ValueError(
                         f'''The model corresponding to this feature extractor: {self} was trained using a sampling rate of'''
                         f''' {self.sampling_rate}. Please make sure that the provided `raw_speech` input was sampled with'''
                         f''' {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."	)

         _A      =			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}'''	)
         _A      =			is_batched_numpy or (
             isinstance(__UpperCAmelCase   ,   (list, tuple)	) and (isinstance(raw_speech[0]   ,   (np.ndarray, tuple, list)	))
         )

         # always return batch
         if not is_batched:
               _A      =			[raw_speech]

         # convert into correct format for padding
         _A      =			BatchFeature({"input_values": raw_speech}	)

         _A      =			self.pad(
             __UpperCAmelCase   ,   padding=__UpperCAmelCase   ,   max_length=__UpperCAmelCase   ,   truncation=__UpperCAmelCase   ,   pad_to_multiple_of=__UpperCAmelCase   ,   return_attention_mask=__UpperCAmelCase   ,   )

         # convert input values to correct format
         _A      =			padded_inputs["input_values"]
         if not isinstance(input_values[0]   ,   np.ndarray	):
               _A      =			[np.asarray(__UpperCAmelCase   ,   dtype=np.floataa	) for array in input_values]
         elif (
             not isinstance(__UpperCAmelCase   ,   np.ndarray	)
             and isinstance(input_values[0]   ,   np.ndarray	)
             and input_values[0].dtype is np.dtype(np.floataa	)
         ):
               _A      =			[array.astype(np.floataa	) for array in input_values]
         elif isinstance(__UpperCAmelCase   ,   np.ndarray	) and input_values.dtype is np.dtype(np.floataa	):
               _A      =			input_values.astype(np.floataa	)

         # convert attention_mask to correct format
         _A      =			padded_inputs.get("attention_mask"	)
         if attention_mask is not None:
               _A      =			[np.asarray(__UpperCAmelCase   ,   dtype=np.intaa	) for array in attention_mask]

         # zero-mean and unit-variance normalization
         if self.do_normalize:
               _A      =			(
                   attention_mask
                   if self._get_padding_strategies(__UpperCAmelCase   ,   max_length=__UpperCAmelCase	) is not PaddingStrategy.DO_NOT_PAD
                   else None
               )
               _A      =			self.zero_mean_unit_var_norm(
                   padded_inputs["input_values"]   ,   attention_mask=__UpperCAmelCase   ,   padding_value=self.padding_value	)

         if return_tensors is not None:
               _A      =			padded_inputs.convert_to_tensors(__UpperCAmelCase	)

         return padded_inputs





