

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     __magic_name__     (							_snake_case     ):
 UpperCAmelCase				     =    ["""input_values""", """attention_mask"""]


 def __init__(    self		:			List[Any]      ,    lowerCAmelCase__		:			List[Any]=1      ,    lowerCAmelCase__		:			Dict=1_6_0_0_0      ,    lowerCAmelCase__		:			Optional[Any]=0.0      ,    lowerCAmelCase__		:			List[str]=False      ,    lowerCAmelCase__		:			Any=True      ,    **lowerCAmelCase__		:			Dict      ,    )     ->   Optional[int]:
   super().__init__(feature_size=lowerCAmelCase__      ,    sampling_rate=lowerCAmelCase__      ,    padding_value=lowerCAmelCase__      ,    **lowerCAmelCase__     )
   UpperCAmelCase          =	return_attention_mask
   UpperCAmelCase          =	do_normalize


 @staticmethod
 def _UpperCamelCase						(    lowerCAmelCase__		:			List[np.ndarray]      ,    lowerCAmelCase__		:			List[np.ndarray]      ,    lowerCAmelCase__		:			float = 0.0     )     ->   List[np.ndarray]:
   if attention_mask is not None:
     UpperCAmelCase          =	np.array(lowerCAmelCase__      ,    np.intaa     )
     UpperCAmelCase          =	[]

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

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

   return normed_input_values


 def __call__(    self		:			Any      ,    lowerCAmelCase__		:			Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]]      ,    lowerCAmelCase__		:			Union[bool, str, PaddingStrategy] = False      ,    lowerCAmelCase__		:			Optional[int] = None      ,    lowerCAmelCase__		:			bool = False      ,    lowerCAmelCase__		:			Optional[int] = None      ,    lowerCAmelCase__		:			Optional[bool] = None      ,    lowerCAmelCase__		:			Optional[Union[str, TensorType]] = None      ,    lowerCAmelCase__		:			Optional[int] = None      ,    **lowerCAmelCase__		:			Tuple      ,    )     ->   BatchFeature:

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

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

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

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

   UpperCAmelCase          =	self.pad(
       lowerCAmelCase__      ,    padding=lowerCAmelCase__      ,    max_length=lowerCAmelCase__      ,    truncation=lowerCAmelCase__      ,    pad_to_multiple_of=lowerCAmelCase__      ,    return_attention_mask=lowerCAmelCase__      ,    )

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

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

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

   if return_tensors is not None:
     UpperCAmelCase          =	padded_inputs.convert_to_tensors(lowerCAmelCase__     )

   return padded_inputs






from typing import TYPE_CHECKING

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


lowerCAmelCase__							=			{
    "configuration_xlm_prophetnet": ["XLM_PROPHETNET_PRETRAINED_CONFIG_ARCHIVE_MAP", "XLMProphetNetConfig"],
}

try:
      if not is_sentencepiece_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      lowerCAmelCase__							=			["XLMProphetNetTokenizer"]

try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      lowerCAmelCase__							=			[
          "XLM_PROPHETNET_PRETRAINED_MODEL_ARCHIVE_LIST",
          "XLMProphetNetDecoder",
          "XLMProphetNetEncoder",
          "XLMProphetNetForCausalLM",
          "XLMProphetNetForConditionalGeneration",
          "XLMProphetNetModel",
          "XLMProphetNetPreTrainedModel",
      ]


if TYPE_CHECKING:
      from .configuration_xlm_prophetnet import XLM_PROPHETNET_PRETRAINED_CONFIG_ARCHIVE_MAP, XLMProphetNetConfig

      try:
            if not is_sentencepiece_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .tokenization_xlm_prophetnet import XLMProphetNetTokenizer

      try:
            if not is_torch_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_xlm_prophetnet import (
                XLM_PROPHETNET_PRETRAINED_MODEL_ARCHIVE_LIST,
                XLMProphetNetDecoder,
                XLMProphetNetEncoder,
                XLMProphetNetForCausalLM,
                XLMProphetNetForConditionalGeneration,
                XLMProphetNetModel,
                XLMProphetNetPreTrainedModel,
            )

else:
      import sys

      lowerCAmelCase__							=			_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)



