





"""simple docstring"""
import importlib
import inspect
import json
import os
from collections import OrderedDict

# Build the list of all feature extractors
from ...configuration_utils import PretrainedConfig
from ...dynamic_module_utils import get_class_from_dynamic_module, resolve_trust_remote_code
from ...feature_extraction_utils import FeatureExtractionMixin
from ...image_processing_utils import ImageProcessingMixin
from ...tokenization_utils import TOKENIZER_CONFIG_FILE
from ...utils import FEATURE_EXTRACTOR_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,
)
from .feature_extraction_auto import AutoFeatureExtractor
from .image_processing_auto import AutoImageProcessor
from .tokenization_auto import AutoTokenizer


_snake_case	:						Dict					=					logging.get_logger(__name__)

_snake_case	:						Any					=					OrderedDict(
    [
        ('align', 'AlignProcessor'),
        ('altclip', 'AltCLIPProcessor'),
        ('bark', 'BarkProcessor'),
        ('blip', 'BlipProcessor'),
        ('blip-2', 'Blip2Processor'),
        ('bridgetower', 'BridgeTowerProcessor'),
        ('chinese_clip', 'ChineseCLIPProcessor'),
        ('clap', 'ClapProcessor'),
        ('clip', 'CLIPProcessor'),
        ('clipseg', 'CLIPSegProcessor'),
        ('flava', 'FlavaProcessor'),
        ('git', 'GitProcessor'),
        ('groupvit', 'CLIPProcessor'),
        ('hubert', 'Wav2Vec2Processor'),
        ('instructblip', 'InstructBlipProcessor'),
        ('layoutlmv2', 'LayoutLMv2Processor'),
        ('layoutlmv3', 'LayoutLMv3Processor'),
        ('markuplm', 'MarkupLMProcessor'),
        ('mctct', 'MCTCTProcessor'),
        ('mgp-str', 'MgpstrProcessor'),
        ('oneformer', 'OneFormerProcessor'),
        ('owlvit', 'OwlViTProcessor'),
        ('pix2struct', 'Pix2StructProcessor'),
        ('sam', 'SamProcessor'),
        ('sew', 'Wav2Vec2Processor'),
        ('sew-d', 'Wav2Vec2Processor'),
        ('speech_to_text', 'Speech2TextProcessor'),
        ('speech_to_text_2', 'Speech2Text2Processor'),
        ('speecht5', 'SpeechT5Processor'),
        ('trocr', 'TrOCRProcessor'),
        ('tvlt', 'TvltProcessor'),
        ('unispeech', 'Wav2Vec2Processor'),
        ('unispeech-sat', 'Wav2Vec2Processor'),
        ('vilt', 'ViltProcessor'),
        ('vision-text-dual-encoder', 'VisionTextDualEncoderProcessor'),
        ('wav2vec2', 'Wav2Vec2Processor'),
        ('wav2vec2-conformer', 'Wav2Vec2Processor'),
        ('wavlm', 'Wav2Vec2Processor'),
        ('whisper', 'WhisperProcessor'),
        ('xclip', 'XCLIPProcessor'),
    ]
)

_snake_case	:						List[str]					=					_LazyAutoMapping(CONFIG_MAPPING_NAMES, PROCESSOR_MAPPING_NAMES)






def    A__							(     UpperCamelCase			):
							for module_name, processors in PROCESSOR_MAPPING_NAMES.items():
														if class_name in processors:
																					A						=    model_type_to_module_name(UpperCamelCase			)

																					A						=    importlib.import_module(F".{module_name}"   ,    "transformers.models"			)
																					try:
																												return getattr(UpperCamelCase   ,    UpperCamelCase			)
																					except AttributeError:
																												continue

							for processor in PROCESSOR_MAPPING._extra_content.values():
														if getattr(UpperCamelCase   ,    "__name__"   ,    UpperCamelCase			) == class_name:
																					return processor

    # 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.
							A						=    importlib.import_module("transformers"			)
							if hasattr(UpperCamelCase   ,    UpperCamelCase			):
														return getattr(UpperCamelCase   ,    UpperCamelCase			)

							return None






class    _UpperCAmelCase  :


					def __init__(   self     :List[str]						):
												raise EnvironmentError(
												    "AutoProcessor is designed to be instantiated "
												    "using the `AutoProcessor.from_pretrained(pretrained_model_name_or_path)` method."						)


					@classmethod
					@replace_list_option_in_docstrings(__UpperCamelCase						)
					def       lowerCamelCase			(   cls     :Any	,			__UpperCamelCase     :int	,			**__UpperCamelCase     :Optional[int]						):
												A						=    kwargs.pop("config"	,			__UpperCamelCase						)
												A						=    kwargs.pop("trust_remote_code"	,			__UpperCamelCase						)
												A						=    True

												A						=    None
												A						=    None

												# First, let's see if we have a preprocessor config.
												# Filter the kwargs for `get_file_from_repo`.
												A						=    {
												    key: kwargs[key] for key in inspect.signature(__UpperCamelCase						).parameters.keys() if key in kwargs
												}
												# Let's start by checking whether the processor class is saved in an image processor
												A						=    get_file_from_repo(
												    __UpperCamelCase	,			__UpperCamelCase	,			**__UpperCamelCase						)
												if preprocessor_config_file is not None:
																			A,      A						=    ImageProcessingMixin.get_image_processor_dict(__UpperCamelCase	,			**__UpperCamelCase						)
																			A						=    config_dict.get("processor_class"	,			__UpperCamelCase						)
																			if "AutoProcessor" in config_dict.get("auto_map"	,			{}						):
																										A						=    config_dict["auto_map"]["AutoProcessor"]

        # If not found, let's check whether the processor class is saved in a feature extractor config
												if preprocessor_config_file is not None and processor_class is None:
																			A,      A						=    FeatureExtractionMixin.get_feature_extractor_dict(__UpperCamelCase	,			**__UpperCamelCase						)
																			A						=    config_dict.get("processor_class"	,			__UpperCamelCase						)
																			if "AutoProcessor" in config_dict.get("auto_map"	,			{}						):
																										A						=    config_dict["auto_map"]["AutoProcessor"]

												if processor_class is None:
																			# Next, let's check whether the processor class is saved in a tokenizer
																			A						=    get_file_from_repo(
																			    __UpperCamelCase	,			__UpperCamelCase	,			**__UpperCamelCase						)
																			if tokenizer_config_file is not None:
																										with open(__UpperCamelCase	,			encoding="utf-8"						) as reader:
																																	A						=    json.load(__UpperCamelCase						)

																										A						=    config_dict.get("processor_class"	,			__UpperCamelCase						)
																										if "AutoProcessor" in config_dict.get("auto_map"	,			{}						):
																																	A						=    config_dict["auto_map"]["AutoProcessor"]

												if processor_class is None:
																			# Otherwise, load config, if it can be loaded.
																			if not isinstance(__UpperCamelCase	,			__UpperCamelCase						):
																										A						=    AutoConfig.from_pretrained(
																										    __UpperCamelCase	,			trust_remote_code=__UpperCamelCase	,			**__UpperCamelCase						)

																			# And check if the config contains the processor class.
																			A						=    getattr(__UpperCamelCase	,			"processor_class"	,			__UpperCamelCase						)
																			if hasattr(__UpperCamelCase	,			"auto_map"						) and "AutoProcessor" in config.auto_map:
																										A						=    config.auto_map["AutoProcessor"]

												if processor_class is not None:
																			A						=    processor_class_from_name(__UpperCamelCase						)

												A						=    processor_auto_map is not None
												A						=    processor_class is not None or type(__UpperCamelCase						) in PROCESSOR_MAPPING
												A						=    resolve_trust_remote_code(
												    __UpperCamelCase	,			__UpperCamelCase	,			__UpperCamelCase	,			__UpperCamelCase						)

												if has_remote_code and trust_remote_code:
																			A						=    get_class_from_dynamic_module(
																			    __UpperCamelCase	,			__UpperCamelCase	,			**__UpperCamelCase						)
																			A						=    kwargs.pop("code_revision"	,			__UpperCamelCase						)
																			if os.path.isdir(__UpperCamelCase						):
																										processor_class.register_for_auto_class()
																			return processor_class.from_pretrained(
																			    __UpperCamelCase	,			trust_remote_code=__UpperCamelCase	,			**__UpperCamelCase						)
												elif processor_class is not None:
																			return processor_class.from_pretrained(
																			    __UpperCamelCase	,			trust_remote_code=__UpperCamelCase	,			**__UpperCamelCase						)
												# Last try: we use the PROCESSOR_MAPPING.
												elif type(__UpperCamelCase						) in PROCESSOR_MAPPING:
																			return PROCESSOR_MAPPING[type(__UpperCamelCase						)].from_pretrained(__UpperCamelCase	,			**__UpperCamelCase						)

												# At this stage, there doesn't seem to be a `Processor` class available for this model, so let's try a
												# tokenizer.
												try:
																			return AutoTokenizer.from_pretrained(
																			    __UpperCamelCase	,			trust_remote_code=__UpperCamelCase	,			**__UpperCamelCase						)
												except Exception:
																			try:
																										return AutoImageProcessor.from_pretrained(
																										    __UpperCamelCase	,			trust_remote_code=__UpperCamelCase	,			**__UpperCamelCase						)
																			except Exception:
																										pass

																			try:
																										return AutoFeatureExtractor.from_pretrained(
																										    __UpperCamelCase	,			trust_remote_code=__UpperCamelCase	,			**__UpperCamelCase						)
																			except Exception:
																										pass

												raise ValueError(
												    f"Unrecognized processing class in {pretrained_model_name_or_path}. Can't instantiate a processor, a "
												    "tokenizer, an image processor or a feature extractor for this model. Make sure the repository contains"
												    "the files of at least one of those processing classes."						)


					@staticmethod
					def       lowerCamelCase			(   __UpperCamelCase     :List[Any]	,			__UpperCamelCase     :Any						):
												PROCESSOR_MAPPING.register(__UpperCamelCase	,			__UpperCamelCase						)









"""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


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






class    _UpperCAmelCase  (      lowercase_					):
					UpperCamelCase						=				['''input_values''', '''attention_mask''']


					def __init__(   self     :str	,			__UpperCamelCase     :List[str]=1	,			__UpperCamelCase     :Tuple=1_60_00	,			__UpperCamelCase     :Optional[int]=0.0	,			__UpperCamelCase     :Optional[int]=False	,			__UpperCamelCase     :Optional[Any]=True	,			**__UpperCamelCase     :Optional[Any]	,			):
												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						):
												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     :Tuple	,			__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     :List[str]	,			):

												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


