

from typing import List, Optional, Union

import numpy as np

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


_SCREAMING_SNAKE_CASE					:  str             =      logging.get_logger(__name__)






class 	UpperCAmelCase__		(	_a	):






  """simple docstring"""


  a									= ["""input_features""", """attention_mask"""]






  def __init__(							self						:		Dict     ,       __lowerCamelCase						:		List[Any]=80     ,       __lowerCamelCase						:		Tuple=1_6000     ,       __lowerCamelCase						:		List[Any]=0.0     ,       __lowerCamelCase						:		Union[str, Any]=10     ,       __lowerCamelCase						:		str=25     ,       __lowerCamelCase						:		Tuple="hamming_window"     ,       __lowerCamelCase						:		Dict=3_2768.0     ,       __lowerCamelCase						:		Union[str, Any]=0.97     ,       __lowerCamelCase						:		Any=1.0     ,       __lowerCamelCase						:		Optional[Any]=True     ,       __lowerCamelCase						:		List[Any]=True     ,       __lowerCamelCase						:		Tuple=False     ,       **__lowerCamelCase						:		Union[str, Any]     ,       )		->							int:
       super().__init__(feature_size=__lowerCAmelCase     ,       sampling_rate=__lowerCAmelCase     ,       padding_value=__lowerCAmelCase     ,       **__lowerCAmelCase )

       SCREAMING_SNAKE_CASE__   =   feature_size
       SCREAMING_SNAKE_CASE__   =   sampling_rate
       SCREAMING_SNAKE_CASE__   =   padding_value
       SCREAMING_SNAKE_CASE__   =   hop_length
       SCREAMING_SNAKE_CASE__   =   win_length
       SCREAMING_SNAKE_CASE__   =   frame_signal_scale
       SCREAMING_SNAKE_CASE__   =   preemphasis_coeff
       SCREAMING_SNAKE_CASE__   =   mel_floor
       SCREAMING_SNAKE_CASE__   =   normalize_means
       SCREAMING_SNAKE_CASE__   =   normalize_vars
       SCREAMING_SNAKE_CASE__   =   win_function
       SCREAMING_SNAKE_CASE__   =   return_attention_mask

       SCREAMING_SNAKE_CASE__   =   win_length * sampling_rate // 1000
       SCREAMING_SNAKE_CASE__   =   hop_length * sampling_rate // 1000

       SCREAMING_SNAKE_CASE__   =   optimal_fft_length(self.sample_size )
       SCREAMING_SNAKE_CASE__   =   (self.n_fft // 2) + 1






  def 				lowercase_		(							self						:		Union[str, Any]     ,       __lowerCamelCase						:		Union[str, Any] )		->							List[Any]:
       if self.win_function == "hamming_window":
            SCREAMING_SNAKE_CASE__   =   window_function(window_length=self.sample_size     ,       name=self.win_function     ,       periodic=__lowerCAmelCase )
       else:
            SCREAMING_SNAKE_CASE__   =   window_function(window_length=self.sample_size     ,       name=self.win_function )

       SCREAMING_SNAKE_CASE__   =   mel_filter_bank(
           num_frequency_bins=self.n_freqs     ,       num_mel_filters=self.feature_size     ,       min_frequency=0.0     ,       max_frequency=self.sampling_rate / 2.0     ,       sampling_rate=self.sampling_rate     ,       )

       SCREAMING_SNAKE_CASE__   =   spectrogram(
           one_waveform * self.frame_signal_scale     ,       window=__lowerCAmelCase     ,       frame_length=self.sample_size     ,       hop_length=self.sample_stride     ,       fft_length=self.n_fft     ,       center=__lowerCAmelCase     ,       preemphasis=self.preemphasis_coeff     ,       mel_filters=__lowerCAmelCase     ,       mel_floor=self.mel_floor     ,       log_mel='''log'''     ,       )
       return msfc_features.T






  def 				lowercase_		(							self						:		Union[str, Any]     ,       __lowerCamelCase						:		int     ,       __lowerCamelCase						:		Union[str, Any]     ,       __lowerCamelCase						:		int )		->							Union[str, Any]:
       # make sure we normalize float32 arrays
       if self.normalize_means:
            SCREAMING_SNAKE_CASE__   =   x[:input_length].mean(axis=0 )
            SCREAMING_SNAKE_CASE__   =   np.subtract(__lowerCAmelCase     ,       __lowerCAmelCase )
       if self.normalize_vars:
            SCREAMING_SNAKE_CASE__   =   x[:input_length].std(axis=0 )
            SCREAMING_SNAKE_CASE__   =   np.divide(__lowerCAmelCase     ,       __lowerCAmelCase )

       if input_length < x.shape[0]:
            SCREAMING_SNAKE_CASE__   =   padding_value

       # make sure array is in float32
       SCREAMING_SNAKE_CASE__   =   x.astype(np.floataa )

       return x






  def 				lowercase_		(							self						:		Union[str, Any]     ,       __lowerCamelCase						:		Optional[Any]     ,       __lowerCamelCase						:		str = None )		->							str:
       SCREAMING_SNAKE_CASE__   =   attention_mask.sum(-1 ) if attention_mask is not None else [x.shape[0] for x in input_features]
       return [self._normalize_one(__lowerCAmelCase     ,       __lowerCAmelCase     ,       self.padding_value ) for x, n in zip(__lowerCAmelCase     ,       __lowerCAmelCase )]







  def __call__(							self						:		Optional[Any]     ,       __lowerCamelCase						:		Optional[int]     ,       __lowerCamelCase						:		Any = False     ,       __lowerCamelCase						:		str = None     ,       __lowerCamelCase						:		Any = False     ,       __lowerCamelCase						:		Union[str, Any] = None     ,       __lowerCamelCase						:		List[Any] = None     ,       __lowerCamelCase						:		Dict = None     ,       __lowerCamelCase						:		Any = None     ,       **__lowerCamelCase						:		Union[str, Any]     ,       )		->							Optional[Any]:

       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.''' )

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

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

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

       # extract fbank features
       SCREAMING_SNAKE_CASE__   =   [self._extract_mfsc_features(__lowerCAmelCase ) for one_waveform in raw_speech]

       # convert into correct format for padding
       SCREAMING_SNAKE_CASE__   =   BatchFeature({'''input_features''': features} )

       SCREAMING_SNAKE_CASE__   =   self.pad(
           __lowerCAmelCase     ,       padding=__lowerCAmelCase     ,       max_length=__lowerCAmelCase     ,       truncation=__lowerCAmelCase     ,       pad_to_multiple_of=__lowerCAmelCase     ,       return_attention_mask=__lowerCAmelCase     ,       **__lowerCAmelCase     ,       )
       # make sure list is in array format
       SCREAMING_SNAKE_CASE__   =   padded_inputs.get('''input_features''' )
       if isinstance(input_features[0]     ,       __lowerCAmelCase ):
            SCREAMING_SNAKE_CASE__   =   [np.asarray(__lowerCAmelCase     ,       dtype=np.floataa ) for feature in input_features]

       SCREAMING_SNAKE_CASE__   =   padded_inputs.get('''attention_mask''' )
       if attention_mask is not None:
            SCREAMING_SNAKE_CASE__   =   [np.asarray(__lowerCAmelCase     ,       dtype=np.intaa ) for array in attention_mask]

       if self.normalize_means or self.normalize_vars:
            SCREAMING_SNAKE_CASE__   =   (
                np.array(__lowerCAmelCase     ,       dtype=np.intaa )
                if self._get_padding_strategies(__lowerCAmelCase     ,       max_length=__lowerCAmelCase ) is not PaddingStrategy.DO_NOT_PAD
                and padding
                else None
            )
            SCREAMING_SNAKE_CASE__   =   self.normalize(
                padded_inputs['''input_features''']     ,       attention_mask=__lowerCAmelCase )

       if return_tensors is not None:
            SCREAMING_SNAKE_CASE__   =   padded_inputs.convert_to_tensors(__lowerCAmelCase )

       return padded_inputs





import importlib
import json
import os
from collections import OrderedDict
from typing import Dict, Optional, Union

# Build the list of all image processors
from ...configuration_utils import PretrainedConfig
from ...dynamic_module_utils import get_class_from_dynamic_module, resolve_trust_remote_code
from ...image_processing_utils import ImageProcessingMixin
from ...utils import CONFIG_NAME, IMAGE_PROCESSOR_NAME, get_file_from_repo, logging
from .auto_factory import _LazyAutoMapping
from .configuration_auto import (
    CONFIG_MAPPING_NAMES,
    AutoConfig,
    model_type_to_module_name,
    replace_list_option_in_docstrings,
)


_SCREAMING_SNAKE_CASE					:  List[str]             =      logging.get_logger(__name__)

_SCREAMING_SNAKE_CASE					:  Tuple             =      OrderedDict(
    [
        ('''align''', '''EfficientNetImageProcessor'''),
        ('''beit''', '''BeitImageProcessor'''),
        ('''bit''', '''BitImageProcessor'''),
        ('''blip''', '''BlipImageProcessor'''),
        ('''blip-2''', '''BlipImageProcessor'''),
        ('''bridgetower''', '''BridgeTowerImageProcessor'''),
        ('''chinese_clip''', '''ChineseCLIPImageProcessor'''),
        ('''clip''', '''CLIPImageProcessor'''),
        ('''clipseg''', '''ViTImageProcessor'''),
        ('''conditional_detr''', '''ConditionalDetrImageProcessor'''),
        ('''convnext''', '''ConvNextImageProcessor'''),
        ('''convnextv2''', '''ConvNextImageProcessor'''),
        ('''cvt''', '''ConvNextImageProcessor'''),
        ('''data2vec-vision''', '''BeitImageProcessor'''),
        ('''deformable_detr''', '''DeformableDetrImageProcessor'''),
        ('''deit''', '''DeiTImageProcessor'''),
        ('''deta''', '''DetaImageProcessor'''),
        ('''detr''', '''DetrImageProcessor'''),
        ('''dinat''', '''ViTImageProcessor'''),
        ('''donut-swin''', '''DonutImageProcessor'''),
        ('''dpt''', '''DPTImageProcessor'''),
        ('''efficientformer''', '''EfficientFormerImageProcessor'''),
        ('''efficientnet''', '''EfficientNetImageProcessor'''),
        ('''flava''', '''FlavaImageProcessor'''),
        ('''focalnet''', '''BitImageProcessor'''),
        ('''git''', '''CLIPImageProcessor'''),
        ('''glpn''', '''GLPNImageProcessor'''),
        ('''groupvit''', '''CLIPImageProcessor'''),
        ('''imagegpt''', '''ImageGPTImageProcessor'''),
        ('''instructblip''', '''BlipImageProcessor'''),
        ('''layoutlmv2''', '''LayoutLMv2ImageProcessor'''),
        ('''layoutlmv3''', '''LayoutLMv3ImageProcessor'''),
        ('''levit''', '''LevitImageProcessor'''),
        ('''mask2former''', '''Mask2FormerImageProcessor'''),
        ('''maskformer''', '''MaskFormerImageProcessor'''),
        ('''mgp-str''', '''ViTImageProcessor'''),
        ('''mobilenet_v1''', '''MobileNetV1ImageProcessor'''),
        ('''mobilenet_v2''', '''MobileNetV2ImageProcessor'''),
        ('''mobilevit''', '''MobileViTImageProcessor'''),
        ('''mobilevit''', '''MobileViTImageProcessor'''),
        ('''mobilevitv2''', '''MobileViTImageProcessor'''),
        ('''nat''', '''ViTImageProcessor'''),
        ('''oneformer''', '''OneFormerImageProcessor'''),
        ('''owlvit''', '''OwlViTImageProcessor'''),
        ('''perceiver''', '''PerceiverImageProcessor'''),
        ('''pix2struct''', '''Pix2StructImageProcessor'''),
        ('''poolformer''', '''PoolFormerImageProcessor'''),
        ('''regnet''', '''ConvNextImageProcessor'''),
        ('''resnet''', '''ConvNextImageProcessor'''),
        ('''sam''', '''SamImageProcessor'''),
        ('''segformer''', '''SegformerImageProcessor'''),
        ('''swiftformer''', '''ViTImageProcessor'''),
        ('''swin''', '''ViTImageProcessor'''),
        ('''swin2sr''', '''Swin2SRImageProcessor'''),
        ('''swinv2''', '''ViTImageProcessor'''),
        ('''table-transformer''', '''DetrImageProcessor'''),
        ('''timesformer''', '''VideoMAEImageProcessor'''),
        ('''tvlt''', '''TvltImageProcessor'''),
        ('''upernet''', '''SegformerImageProcessor'''),
        ('''van''', '''ConvNextImageProcessor'''),
        ('''videomae''', '''VideoMAEImageProcessor'''),
        ('''vilt''', '''ViltImageProcessor'''),
        ('''vit''', '''ViTImageProcessor'''),
        ('''vit_hybrid''', '''ViTHybridImageProcessor'''),
        ('''vit_mae''', '''ViTImageProcessor'''),
        ('''vit_msn''', '''ViTImageProcessor'''),
        ('''xclip''', '''CLIPImageProcessor'''),
        ('''yolos''', '''YolosImageProcessor'''),
    ]
)

_SCREAMING_SNAKE_CASE					:  str             =      _LazyAutoMapping(CONFIG_MAPPING_NAMES, IMAGE_PROCESSOR_MAPPING_NAMES)
def     UpperCAmelCase_       (						_A    ):





     '''simple docstring'''




     for module_name, extractors in IMAGE_PROCESSOR_MAPPING_NAMES.items():
          if class_name in extractors:
               SCREAMING_SNAKE_CASE__   =   model_type_to_module_name(_A    )

               SCREAMING_SNAKE_CASE__   =   importlib.import_module(F'''.{module_name}'''				,		'''transformers.models'''    )
               try:
                    return getattr(_A				,		_A    )
               except AttributeError:
                    continue

     for _, extractor in IMAGE_PROCESSOR_MAPPING._extra_content.items():
          if getattr(_A				,		'''__name__'''				,		_A    ) == class_name:
               return extractor

    # We did not fine the class, but maybe it's because a dep is missing. In that case, the class will be in the main
    # init and we return the proper dummy to get an appropriate error message.
     SCREAMING_SNAKE_CASE__   =   importlib.import_module('''transformers'''    )
     if hasattr(_A				,		_A    ):
          return getattr(_A				,		_A    )

     return None
def     UpperCAmelCase_       (						_A				,		_A = None				,		_A = False				,		_A = False				,		_A = None				,		_A = None				,		_A = None				,		_A = False				,		**_A				,		):





     '''simple docstring'''




     SCREAMING_SNAKE_CASE__   =   get_file_from_repo(
         _A				,		_A				,		cache_dir=_A				,		force_download=_A				,		resume_download=_A				,		proxies=_A				,		use_auth_token=_A				,		revision=_A				,		local_files_only=_A				,		)
     if resolved_config_file is None:
          logger.info(
              '''Could not locate the image processor configuration file, will try to use the model config instead.'''    )
          return {}

     with open(_A				,		encoding='''utf-8'''    ) as reader:
          return json.load(_A    )







class 	UpperCAmelCase__		:






  """simple docstring"""


  def __init__(							self						:		List[Any] )		->							int:
       raise EnvironmentError(
           '''AutoImageProcessor is designed to be instantiated '''
           '''using the `AutoImageProcessor.from_pretrained(pretrained_model_name_or_path)` method.''' )






  @classmethod
  @replace_list_option_in_docstrings(__lowerCamelCase )
  def 				lowercase_		(							cls						:		Optional[int]     ,       __lowerCamelCase						:		Any     ,       **__lowerCamelCase						:		Tuple )		->							List[str]:
       SCREAMING_SNAKE_CASE__   =   kwargs.pop('''config'''     ,       __lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   kwargs.pop('''trust_remote_code'''     ,       __lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   True

       SCREAMING_SNAKE_CASE__,SCREAMING_SNAKE_CASE__   =   ImageProcessingMixin.get_image_processor_dict(__lowerCamelCase     ,       **__lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   config_dict.get('''image_processor_type'''     ,       __lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   None
       if "AutoImageProcessor" in config_dict.get('''auto_map'''     ,       {} ):
            SCREAMING_SNAKE_CASE__   =   config_dict['''auto_map''']['''AutoImageProcessor''']

       # If we still don't have the image processor class, check if we're loading from a previous feature extractor config
       # and if so, infer the image processor class from there.
       if image_processor_class is None and image_processor_auto_map is None:
            SCREAMING_SNAKE_CASE__   =   config_dict.pop('''feature_extractor_type'''     ,       __lowerCamelCase )
            if feature_extractor_class is not None:
                 logger.warning(
                     '''Could not find image processor class in the image processor config or the model config. Loading'''
                     ''' based on pattern matching with the model\'s feature extractor configuration.''' )
                 SCREAMING_SNAKE_CASE__   =   feature_extractor_class.replace('''FeatureExtractor'''     ,       '''ImageProcessor''' )
            if "AutoFeatureExtractor" in config_dict.get('''auto_map'''     ,       {} ):
                 SCREAMING_SNAKE_CASE__   =   config_dict['''auto_map''']['''AutoFeatureExtractor''']
                 SCREAMING_SNAKE_CASE__   =   feature_extractor_auto_map.replace('''FeatureExtractor'''     ,       '''ImageProcessor''' )
                 logger.warning(
                     '''Could not find image processor auto map in the image processor config or the model config.'''
                     ''' Loading based on pattern matching with the model\'s feature extractor configuration.''' )

        # If we don't find the image processor class in the image processor config, let's try the model config.
       if image_processor_class is None and image_processor_auto_map is None:
            if not isinstance(__lowerCamelCase     ,       __lowerCamelCase ):
                 SCREAMING_SNAKE_CASE__   =   AutoConfig.from_pretrained(__lowerCamelCase     ,       **__lowerCamelCase )
            # It could be in `config.image_processor_type``
            SCREAMING_SNAKE_CASE__   =   getattr(__lowerCamelCase     ,       '''image_processor_type'''     ,       __lowerCamelCase )
            if hasattr(__lowerCamelCase     ,       '''auto_map''' ) and "AutoImageProcessor" in config.auto_map:
                 SCREAMING_SNAKE_CASE__   =   config.auto_map['''AutoImageProcessor''']

       if image_processor_class is not None:
            SCREAMING_SNAKE_CASE__   =   image_processor_class_from_name(__lowerCamelCase )

       SCREAMING_SNAKE_CASE__   =   image_processor_auto_map is not None
       SCREAMING_SNAKE_CASE__   =   image_processor_class is not None or type(__lowerCamelCase ) in IMAGE_PROCESSOR_MAPPING
       SCREAMING_SNAKE_CASE__   =   resolve_trust_remote_code(
           __lowerCamelCase     ,       __lowerCamelCase     ,       __lowerCamelCase     ,       __lowerCamelCase )

       if has_remote_code and trust_remote_code:
            SCREAMING_SNAKE_CASE__   =   get_class_from_dynamic_module(
                __lowerCamelCase     ,       __lowerCamelCase     ,       **__lowerCamelCase )
            SCREAMING_SNAKE_CASE__   =   kwargs.pop('''code_revision'''     ,       __lowerCamelCase )
            if os.path.isdir(__lowerCamelCase ):
                 image_processor_class.register_for_auto_class()
            return image_processor_class.from_dict(__lowerCamelCase     ,       **__lowerCamelCase )
       elif image_processor_class is not None:
            return image_processor_class.from_dict(__lowerCamelCase     ,       **__lowerCamelCase )
       # Last try: we use the IMAGE_PROCESSOR_MAPPING.
       elif type(__lowerCamelCase ) in IMAGE_PROCESSOR_MAPPING:
            SCREAMING_SNAKE_CASE__   =   IMAGE_PROCESSOR_MAPPING[type(__lowerCamelCase )]
            return image_processor_class.from_dict(__lowerCamelCase     ,       **__lowerCamelCase )

       raise ValueError(
           f'''Unrecognized image processor in {pretrained_model_name_or_path}. Should have a '''
           f'''`image_processor_type` key in its {IMAGE_PROCESSOR_NAME} of {CONFIG_NAME}, or one of the following '''
           f'''`model_type` keys in its {CONFIG_NAME}: {", ".join(c for c in IMAGE_PROCESSOR_MAPPING_NAMES.keys() )}''' )







  @staticmethod
  def 				lowercase_		(							__lowerCamelCase						:		Dict     ,       __lowerCamelCase						:		Optional[int] )		->							str:
       IMAGE_PROCESSOR_MAPPING.register(__lowerCamelCase     ,       __lowerCamelCase )


