






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


SCREAMING_SNAKE_CASE__											=     logging.get_logger(__name__)






class        a_		(    lowerCamelCase       ):
  lowercase  	=   ["""input_features"""]

  def __init__(   self    ,	_SCREAMING_SNAKE_CASE=80    ,	_SCREAMING_SNAKE_CASE=16000    ,	_SCREAMING_SNAKE_CASE=160    ,	_SCREAMING_SNAKE_CASE=30    ,	_SCREAMING_SNAKE_CASE=400    ,	_SCREAMING_SNAKE_CASE=0.0    ,	_SCREAMING_SNAKE_CASE=False    ,	**_SCREAMING_SNAKE_CASE    ,	)						->   Any:



        """simple docstring"""






        super().__init__(
            feature_size=_SCREAMING_SNAKE_CASE    ,	sampling_rate=_SCREAMING_SNAKE_CASE    ,	padding_value=_SCREAMING_SNAKE_CASE    ,	return_attention_mask=_SCREAMING_SNAKE_CASE    ,	**_SCREAMING_SNAKE_CASE    ,	)
        UpperCamelCase       						=      n_fft
        UpperCamelCase       						=      hop_length
        UpperCamelCase       						=      chunk_length
        UpperCamelCase       						=      chunk_length * sampling_rate
        UpperCamelCase       						=      self.n_samples // hop_length
        UpperCamelCase       						=      sampling_rate
        UpperCamelCase       						=      mel_filter_bank(
            num_frequency_bins=1 + n_fft // 2    ,	num_mel_filters=_SCREAMING_SNAKE_CASE    ,	min_frequency=0.0    ,	max_frequency=8_0_0_0.0    ,	sampling_rate=_SCREAMING_SNAKE_CASE    ,	norm="""slaney"""    ,	mel_scale="""slaney"""    ,	)

  def 						A__		(   self    ,	_SCREAMING_SNAKE_CASE   )						->   np.ndarray:



        """simple docstring"""






        UpperCamelCase       						=      spectrogram(
            _SCREAMING_SNAKE_CASE    ,	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"""    ,	)
        UpperCamelCase       						=      log_spec[:, :-1]
        UpperCamelCase       						=      np.maximum(_SCREAMING_SNAKE_CASE    ,	log_spec.max() - 8.0   )
        UpperCamelCase       						=      (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 						A__		(   _SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE = 0.0   )						->   List[np.ndarray]:



        """simple docstring"""






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

              for vector, length in zip(_SCREAMING_SNAKE_CASE    ,	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(_SCREAMING_SNAKE_CASE   )
        else:
              UpperCamelCase       						=      [(x - x.mean()) / np.sqrt(x.var() + 1e-7   ) for x in input_values]

        return normed_input_values

  def __call__(   self    ,	_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE = True    ,	_SCREAMING_SNAKE_CASE = None    ,	_SCREAMING_SNAKE_CASE = None    ,	_SCREAMING_SNAKE_CASE = None    ,	_SCREAMING_SNAKE_CASE = "max_length"    ,	_SCREAMING_SNAKE_CASE = None    ,	_SCREAMING_SNAKE_CASE = None    ,	_SCREAMING_SNAKE_CASE = None    ,	**_SCREAMING_SNAKE_CASE    ,	)						->   BatchFeature:



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

        UpperCamelCase       						=      isinstance(_SCREAMING_SNAKE_CASE    ,	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(_SCREAMING_SNAKE_CASE    ,	(list, tuple)   ) and (isinstance(raw_speech[0]    ,	(np.ndarray, tuple, list)   ))
        )

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

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

        UpperCamelCase       						=      BatchFeature({"""input_features""": raw_speech}   )

        # convert into correct format for padding

        UpperCamelCase       						=      self.pad(
            _SCREAMING_SNAKE_CASE    ,	padding=_SCREAMING_SNAKE_CASE    ,	max_length=max_length if max_length else self.n_samples    ,	truncation=_SCREAMING_SNAKE_CASE    ,	pad_to_multiple_of=_SCREAMING_SNAKE_CASE    ,	return_attention_mask=return_attention_mask or do_normalize    ,	)

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

        # make sure list is in array format
        UpperCamelCase       						=      padded_inputs.get("""input_features"""   ).transpose(2    ,	0    ,	1   )

        UpperCamelCase       						=      [self._np_extract_fbank_features(_SCREAMING_SNAKE_CASE   ) for waveform in input_features[0]]

        if isinstance(input_features[0]    ,	_SCREAMING_SNAKE_CASE   ):
              UpperCamelCase       						=      [np.asarray(_SCREAMING_SNAKE_CASE    ,	dtype=np.floataa   ) for feature in input_features]
        else:
              UpperCamelCase       						=      input_features

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

        if return_tensors is not None:
              UpperCamelCase       						=      padded_inputs.convert_to_tensors(_SCREAMING_SNAKE_CASE   )

        return padded_inputs


  def 						A__		(   self   )						->   Dict[str, Any]:



        """simple docstring"""






        UpperCamelCase       						=      copy.deepcopy(self.__dict__   )
        UpperCamelCase       						=      self.__class__.__name__
        if "mel_filters" in output:
              del output["mel_filters"]
        return output








'''simple docstring'''

import importlib.util
import os
import platform
from argparse import ArgumentParser

import huggingface_hub

from .. import __version__ as version
from ..utils import (
    is_accelerate_available,
    is_flax_available,
    is_safetensors_available,
    is_tf_available,
    is_torch_available,
)
from . import BaseTransformersCLICommand







def 					lowercase__				(   __UpperCamelCase					)->				str:
      return EnvironmentCommand()







def 					lowercase__				(   __UpperCamelCase					)->				str:
      return EnvironmentCommand(args.accelerate_config_file					)






class        a_		(    lowerCamelCase       ):

  @staticmethod
  def 						A__		(   _SCREAMING_SNAKE_CASE   )						->   Optional[Any]:



        """simple docstring"""






        UpperCamelCase       						=      parser.add_parser("""env"""   )
        download_parser.set_defaults(func=_SCREAMING_SNAKE_CASE   )
        download_parser.add_argument(
            """--accelerate-config_file"""    ,	default=_SCREAMING_SNAKE_CASE    ,	help="""The accelerate config file to use for the default values in the launching script."""    ,	)
        download_parser.set_defaults(func=_SCREAMING_SNAKE_CASE   )

  def __init__(   self    ,	_SCREAMING_SNAKE_CASE    ,	*_SCREAMING_SNAKE_CASE   )						->   None:



        """simple docstring"""






        UpperCamelCase       						=      accelerate_config_file

  def 						A__		(   self   )						->   List[Any]:



        """simple docstring"""






        UpperCamelCase       						=      """not installed"""
        if is_safetensors_available():
              import safetensors

              UpperCamelCase       						=      safetensors.__version__
        elif importlib.util.find_spec("""safetensors"""   ) is not None:
              import safetensors

              UpperCamelCase       						=      F"{safetensors.__version__} but is ignored because of PyTorch version too old."

        UpperCamelCase       						=      """not installed"""
        UpperCamelCase       						=      UpperCamelCase       						=      """not found"""
        if is_accelerate_available():
              import accelerate
              from accelerate.commands.config import default_config_file, load_config_from_file

              UpperCamelCase       						=      accelerate.__version__
              # Get the default from the config file.
              if self._accelerate_config_file is not None or os.path.isfile(_SCREAMING_SNAKE_CASE   ):
                    UpperCamelCase       						=      load_config_from_file(self._accelerate_config_file   ).to_dict()

              UpperCamelCase       						=      (
                  """\n""".join([F"\t- {prop}: {val}" for prop, val in accelerate_config.items()]   )
                  if isinstance(_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE   )
                  else F"\t{accelerate_config}"
              )

        UpperCamelCase       						=      """not installed"""
        UpperCamelCase       						=      """NA"""
        if is_torch_available():
              import torch

              UpperCamelCase       						=      torch.__version__
              UpperCamelCase       						=      torch.cuda.is_available()

        UpperCamelCase       						=      """not installed"""
        UpperCamelCase       						=      """NA"""
        if is_tf_available():
              import tensorflow as tf

              UpperCamelCase       						=      tf.__version__
              try:
                    # deprecated in v2.1
                    UpperCamelCase       						=      tf.test.is_gpu_available()
              except AttributeError:
                    # returns list of devices, convert to bool
                    UpperCamelCase       						=      bool(tf.config.list_physical_devices("""GPU"""   )   )

        UpperCamelCase       						=      """not installed"""
        UpperCamelCase       						=      """not installed"""
        UpperCamelCase       						=      """not installed"""
        UpperCamelCase       						=      """NA"""
        if is_flax_available():
              import flax
              import jax
              import jaxlib

              UpperCamelCase       						=      flax.__version__
              UpperCamelCase       						=      jax.__version__
              UpperCamelCase       						=      jaxlib.__version__
              UpperCamelCase       						=      jax.lib.xla_bridge.get_backend().platform

        UpperCamelCase       						=      {
            """`transformers` version""": version,
            """Platform""": platform.platform(),
            """Python version""": platform.python_version(),
            """Huggingface_hub version""": huggingface_hub.__version__,
            """Safetensors version""": F"{safetensors_version}",
            """Accelerate version""": F"{accelerate_version}",
            """Accelerate config""": F"{accelerate_config_str}",
            """PyTorch version (GPU?)""": F"{pt_version} ({pt_cuda_available})",
            """Tensorflow version (GPU?)""": F"{tf_version} ({tf_cuda_available})",
            """Flax version (CPU?/GPU?/TPU?)""": F"{flax_version} ({jax_backend})",
            """Jax version""": F"{jax_version}",
            """JaxLib version""": F"{jaxlib_version}",
            """Using GPU in script?""": """<fill in>""",
            """Using distributed or parallel set-up in script?""": """<fill in>""",
        }

        print("""\nCopy-and-paste the text below in your GitHub issue and FILL OUT the two last points.\n"""   )
        print(self.format_dict(_SCREAMING_SNAKE_CASE   )   )

        return info


  @staticmethod
  def 						A__		(   _SCREAMING_SNAKE_CASE   )						->   Dict:



        """simple docstring"""






        return "\n".join([F"- {prop}: {val}" for prop, val in d.items()]   ) + "\n"
