






"""simple docstring"""
from typing import TYPE_CHECKING

from ....utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available


snake_case   :   Any    		=		{
    """configuration_retribert""": ["""RETRIBERT_PRETRAINED_CONFIG_ARCHIVE_MAP""", """RetriBertConfig"""],
    """tokenization_retribert""": ["""RetriBertTokenizer"""],
}

try:
 if not is_tokenizers_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 snake_case   :   int    		=		["""RetriBertTokenizerFast"""]

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 snake_case   :   Any    		=		[
     """RETRIBERT_PRETRAINED_MODEL_ARCHIVE_LIST""",
     """RetriBertModel""",
     """RetriBertPreTrainedModel""",
 ]


if TYPE_CHECKING:
 from .configuration_retribert import RETRIBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, RetriBertConfig
 from .tokenization_retribert import RetriBertTokenizer

 try:
  if not is_tokenizers_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .tokenization_retribert_fast import RetriBertTokenizerFast

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_retribert import (
      RETRIBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
      RetriBertModel,
      RetriBertPreTrainedModel,
  )

else:
 import sys

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







"""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   :   Tuple    		=		logging.get_logger(__name__)



class 					UpperCamelCase__   (							a_):







    """simple docstring"""
    __UpperCAmelCase											=   ["""input_values""", """attention_mask"""]







    def __init__(		self   :  Union[str, Any]							,						UpperCamelCase_   :  int=1							,						UpperCamelCase_   :  Optional[int]=1_6_0_0_0							,						UpperCamelCase_   :  List[str]=0.0							,						UpperCamelCase_   :  Optional[int]=False							,						UpperCamelCase_   :  Tuple=True							,						**UpperCamelCase_   :  Tuple							,						):





           '''simple docstring'''

           super().__init__(feature_size=UpperCamelCase_							,						sampling_rate=UpperCamelCase_							,						padding_value=UpperCamelCase_							,						**UpperCamelCase_   )
           __magic_name__										=						return_attention_mask
           __magic_name__										=						do_normalize







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





           '''simple docstring'''

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

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

                         normed_input_values.append(UpperCamelCase_   )
           else:
                  __magic_name__										=						[(x - x.mean()) / np.sqrt(x.var() + 1e-7   ) for x in input_values]

           return normed_input_values







    def __call__(		self   :  Any							,						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_   :  Any							,						):





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

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

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

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

           __magic_name__										=						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
           __magic_name__										=						padded_inputs['input_values']
           if not isinstance(input_values[0]							,						np.ndarray   ):
                  __magic_name__										=						[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   )
           ):
                  __magic_name__										=						[array.astype(np.floataa   ) for array in input_values]
           elif isinstance(UpperCamelCase_							,						np.ndarray   ) and input_values.dtype is np.dtype(np.floataa   ):
                  __magic_name__										=						input_values.astype(np.floataa   )

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

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

           if return_tensors is not None:
                  __magic_name__										=						padded_inputs.convert_to_tensors(UpperCamelCase_   )

           return padded_inputs