



"""simple docstring"""






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


_lowercase			:			int										=						logging.get_logger(__name__)

class 	__SCREAMING_SNAKE_CASE     (				lowerCAmelCase_       ):


					'''simple docstring'''





					_a             =							['input_features']



					def __init__(	self							:  int,  lowerCamelCase							:  Optional[Any]=80,  lowerCamelCase							:  Any=1_6000,  lowerCamelCase							:  Tuple=160,  lowerCamelCase							:  List[Any]=30,  lowerCamelCase							:  Any=400,  lowerCamelCase							:  Optional[Any]=0.0,  lowerCamelCase							:  Union[str, Any]=False,  **lowerCamelCase							:  Optional[int],  )-> Any:
								super().__init__(
								    feature_size=lowerCamelCase,  sampling_rate=lowerCamelCase,  padding_value=lowerCamelCase,  return_attention_mask=lowerCamelCase,  **lowerCamelCase,  )
								lowerCamelCase__		:		List[str]		     =n_fft
								lowerCamelCase__		:		List[str]		     =hop_length
								lowerCamelCase__		:		Dict		     =chunk_length
								lowerCamelCase__		:		int		     =chunk_length * sampling_rate
								lowerCamelCase__		:		Union[str, Any]		     =self.n_samples // hop_length
								lowerCamelCase__		:		Dict		     =sampling_rate
								lowerCamelCase__		:		Dict		     =mel_filter_bank(
								    num_frequency_bins=1 + n_fft // 2,  num_mel_filters=lowerCamelCase,  min_frequency=0.0,  max_frequency=8000.0,  sampling_rate=lowerCamelCase,  norm='''slaney''',  mel_scale='''slaney''',  )



					def 		snake_case	(	self							:  Optional[Any],  lowerCamelCase							:  np.array					)-> np.ndarray:
								lowerCamelCase__		:		Optional[int]		     =spectrogram(
								    lowerCamelCase,  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''',  )
								lowerCamelCase__		:		Any		     =log_spec[:, :-1]
								lowerCamelCase__		:		Dict		     =np.maximum(lowerCamelCase,  log_spec.max() - 8.0					)
								lowerCamelCase__		:		str		     =(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 		snake_case	(	lowerCamelCase							:  List[np.ndarray],  lowerCamelCase							:  List[np.ndarray],  lowerCamelCase							:  float = 0.0					)-> List[np.ndarray]:
								if attention_mask is not None:
											lowerCamelCase__		:		Tuple		     =np.array(lowerCamelCase,  np.intaa					)
											lowerCamelCase__		:		str		     =[]

											for vector, length in zip(lowerCamelCase,  attention_mask.sum(-1					)					):
														lowerCamelCase__		:		Union[str, Any]		     =(vector - vector[:length].mean()) / np.sqrt(vector[:length].var() + 1E-7					)
														if length < normed_slice.shape[0]:
																	lowerCamelCase__		:		List[Any]		     =padding_value

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

								return normed_input_values



					def __call__(	self							:  List[Any],  lowerCamelCase							:  Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]],  lowerCamelCase							:  bool = True,  lowerCamelCase							:  Optional[int] = None,  lowerCamelCase							:  Optional[Union[str, TensorType]] = None,  lowerCamelCase							:  Optional[bool] = None,  lowerCamelCase							:  Optional[str] = "max_length",  lowerCamelCase							:  Optional[int] = None,  lowerCamelCase							:  Optional[int] = None,  lowerCamelCase							:  Optional[bool] = None,  **lowerCamelCase							:  str,  )-> BatchFeature:

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

								lowerCamelCase__		:		Optional[Any]		     =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}'''					)
								lowerCamelCase__		:		str		     =is_batched_numpy or (
								    isinstance(lowerCamelCase,  (list, tuple)					) and (isinstance(raw_speech[0],  (np.ndarray, tuple, list)					))
								)

								if is_batched:
											lowerCamelCase__		:		Tuple		     =[np.asarray([speech],  dtype=np.floataa					).T for speech in raw_speech]
								elif not is_batched and not isinstance(lowerCamelCase,  np.ndarray					):
											lowerCamelCase__		:		int		     =np.asarray(lowerCamelCase,  dtype=np.floataa					)
								elif isinstance(lowerCamelCase,  np.ndarray					) and raw_speech.dtype is np.dtype(np.floataa					):
											lowerCamelCase__		:		Any		     =raw_speech.astype(np.floataa					)

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

								lowerCamelCase__		:		Any		     =BatchFeature({'''input_features''': raw_speech}					)

								# convert into correct format for padding

								lowerCamelCase__		:		List[str]		     =self.pad(
								    lowerCamelCase,  padding=lowerCamelCase,  max_length=max_length if max_length else self.n_samples,  truncation=lowerCamelCase,  pad_to_multiple_of=lowerCamelCase,  return_attention_mask=return_attention_mask or do_normalize,  )

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

								# make sure list is in array format
								lowerCamelCase__		:		Optional[Any]		     =padded_inputs.get('''input_features'''					).transpose(2,  0,  1					)

								lowerCamelCase__		:		Union[str, Any]		     =[self._np_extract_fbank_features(lowerCamelCase					) for waveform in input_features[0]]

								if isinstance(input_features[0],  lowerCamelCase					):
											lowerCamelCase__		:		Union[str, Any]		     =[np.asarray(lowerCamelCase,  dtype=np.floataa					) for feature in input_features]
								else:
											lowerCamelCase__		:		Any		     =input_features

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

								if return_tensors is not None:
											lowerCamelCase__		:		int		     =padded_inputs.convert_to_tensors(lowerCamelCase					)

								return padded_inputs




					def 		snake_case	(	self							:  List[str]					)-> Dict[str, Any]:
								lowerCamelCase__		:		List[str]		     =copy.deepcopy(self.__dict__					)
								lowerCamelCase__		:		List[Any]		     =self.__class__.__name__
								if "mel_filters" in output:
											del output["mel_filters"]
								return output









"""simple docstring"""






from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_sentencepiece_available,
    is_speech_available,
    is_torch_available,
)


_lowercase			:			Any										=						{
    "configuration_trocr": ["TROCR_PRETRAINED_CONFIG_ARCHIVE_MAP", "TrOCRConfig"],
    "processing_trocr": ["TrOCRProcessor"],
}


try:
		if not is_torch_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		_lowercase			:			List[Any]										=						[
		    "TROCR_PRETRAINED_MODEL_ARCHIVE_LIST",
		    "TrOCRForCausalLM",
		    "TrOCRPreTrainedModel",
		]


if TYPE_CHECKING:
		from .configuration_trocr import TROCR_PRETRAINED_CONFIG_ARCHIVE_MAP, TrOCRConfig
		from .processing_trocr import TrOCRProcessor

		try:
				if not is_torch_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_trocr import TROCR_PRETRAINED_MODEL_ARCHIVE_LIST, TrOCRForCausalLM, TrOCRPreTrainedModel

else:
		import sys

		_lowercase			:			Tuple										=						_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)




