

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


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

class   __UpperCamelCase      (   lowercase  ):
	SCREAMING_SNAKE_CASE__      			=       ['input_values', 'attention_mask']




	def __init__(						self		:  str						,		lowerCAmelCase		:  Dict=1						,		lowerCAmelCase		:  Optional[Any]=16_000						,		lowerCAmelCase		:  Optional[Any]=0.0						,		lowerCAmelCase		:  Union[str, Any]=False						,		lowerCAmelCase		:  Dict=True						,		**lowerCAmelCase		:  Tuple						,		):


		'''simple docstring'''







		super().__init__(feature_size=lowerCAmelCase						,		sampling_rate=lowerCAmelCase						,		padding_value=lowerCAmelCase						,		**lowerCAmelCase							)
		UpperCAmelCase_    			=     return_attention_mask
		UpperCAmelCase_    			=     do_normalize




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


		'''simple docstring'''







		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		:  Optional[int]						,		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		:  Dict						,		):


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

		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






import importlib
import importlib.metadata
import os
import warnings
from distutils.util import strtobool
from functools import lru_cache

import torch
from packaging import version
from packaging.version import parse

from .environment import parse_flag_from_env
from .versions import compare_versions, is_torch_version


try:
				import torch_xla.core.xla_model as xm  # noqa: F401

				_a:      List[Any]								=     True
except ImportError:
				_a:      int								=     False


# Cache this result has it's a C FFI call which can be pretty time-consuming
_a:      str								=     torch.distributed.is_available()



def  __lowerCAmelCase (  A      ):
	# Check we're not importing a "pkg_name" directory somewhere but the actual library by trying to grab the version
	UpperCAmelCase_    			=     importlib.util.find_spec(A      ) is not None
	if package_exists:
		try:
			UpperCAmelCase_    			=     importlib.metadata.metadata(A      )
			return True
		except importlib.metadata.PackageNotFoundError:
			return False



def  __lowerCAmelCase (  ):
	return _torch_distributed_available



def  __lowerCAmelCase (  ):
	try:
		pass
	except ImportError:
		print(
		    "Intel(R) oneCCL Bindings for PyTorch* is required to run DDP on Intel(R) GPUs, but it is not"
		    " detected. If you see \"ValueError: Invalid backend: 'ccl'\" error, please install Intel(R) oneCCL"
		    " Bindings for PyTorch*."      )
	return (
	    importlib.util.find_spec("torch_ccl"      ) is not None
	    or importlib.util.find_spec("oneccl_bindings_for_pytorch"      ) is not None
	)



def  __lowerCAmelCase (  ):
	return importlib.metadata.version("oneccl_bind_pt"      )



def  __lowerCAmelCase (  ):
	return _is_package_available("transformer_engine"      )



@lru_cache
def  __lowerCAmelCase (  A=True      ):
	# Due to bugs on the amp series GPUs, we disable torch-xla on them
	if torch.cuda.is_available():
		return False
	if _tpu_available and check_device:
		try:
			# Will raise a RuntimeError if no XLA configuration is found
			UpperCAmelCase_    			=     xm.xla_device()
			return True
		except RuntimeError:
			return False
	return _tpu_available



def  __lowerCAmelCase (  ):
	return _is_package_available("deepspeed"      )



def  __lowerCAmelCase (  A=False      ):
	if is_tpu_available():
		return not ignore_tpu
	if torch.cuda.is_available():
		return torch.cuda.is_bfaa_supported()
	if is_npu_available():
		return False
	return True



def  __lowerCAmelCase (  ):
	UpperCAmelCase_    			=     _is_package_available("bitsandbytes"      )
	if package_exists:
		UpperCAmelCase_    			=     version.parse(importlib.metadata.version("bitsandbytes"      )      )
		return compare_versions(A    ,       ">="    ,       "0.39.0"      )
	return False



def  __lowerCAmelCase (  ):
	UpperCAmelCase_    			=     _is_package_available("bitsandbytes"      )
	if package_exists:
		UpperCAmelCase_    			=     version.parse(importlib.metadata.version("bitsandbytes"      )      )
		return compare_versions(A    ,       ">="    ,       "0.37.2"      )
	return False



def  __lowerCAmelCase (  ):
	return _is_package_available("bitsandbytes"      )



def  __lowerCAmelCase (  ):
	if strtobool(os.environ.get("ACCELERATE_USE_MEGATRON_LM"    ,       "False"      )      ) == 1:
		UpperCAmelCase_    			=     importlib.util.find_spec("megatron"      ) is not None
		if package_exists:
			try:
				UpperCAmelCase_    			=     parse(importlib.metadata.version("megatron-lm"      )      )
				return compare_versions(A    ,       ">="    ,       "2.2.0"      )
			except Exception as e:
				warnings.warn(F"Parse Megatron version failed. Exception:{e}"      )
				return False



def  __lowerCAmelCase (  ):
	return _is_package_available("safetensors"      )



def  __lowerCAmelCase (  ):
	return _is_package_available("transformers"      )



def  __lowerCAmelCase (  ):
	return _is_package_available("datasets"      )



def  __lowerCAmelCase (  ):
	return _is_package_available("aim"      )



def  __lowerCAmelCase (  ):
	return _is_package_available("tensorboard"      ) or _is_package_available("tensorboardX"      )



def  __lowerCAmelCase (  ):
	return _is_package_available("wandb"      )



def  __lowerCAmelCase (  ):
	return _is_package_available("comet_ml"      )



def  __lowerCAmelCase (  ):
	return _is_package_available("boto3"      )



def  __lowerCAmelCase (  ):
	if _is_package_available("rich"      ):
		if "ACCELERATE_DISABLE_RICH" in os.environ:
			warnings.warn(
			    "`ACCELERATE_DISABLE_RICH` is deprecated and will be removed in v0.22.0 and deactivated by default. Please use `ACCELERATE_ENABLE_RICH` if you wish to use `rich`."      )
			return not parse_flag_from_env("ACCELERATE_DISABLE_RICH"    ,       A      )
		return parse_flag_from_env("ACCELERATE_ENABLE_RICH"    ,       A      )
	return False



def  __lowerCAmelCase (  ):
	return _is_package_available("sagemaker"      )



def  __lowerCAmelCase (  ):
	return _is_package_available("tqdm"      )



def  __lowerCAmelCase (  ):
	return _is_package_available("mlflow"      )



def  __lowerCAmelCase (  ):
	return is_torch_version(">="    ,       "1.12"      ) and torch.backends.mps.is_available() and torch.backends.mps.is_built()



def  __lowerCAmelCase (  ):
	def get_major_and_minor_from_version(A      ):
		return str(version.parse(A      ).major      ) + "." + str(version.parse(A      ).minor      )

	UpperCAmelCase_    			=     importlib.metadata.version("torch"      )
	if importlib.util.find_spec("intel_extension_for_pytorch"      ) is None:
		return False
	UpperCAmelCase_    			=     "N/A"
	try:
		UpperCAmelCase_    			=     importlib.metadata.version("intel_extension_for_pytorch"      )
	except importlib.metadata.PackageNotFoundError:
		return False
	UpperCAmelCase_    			=     get_major_and_minor_from_version(_torch_version      )
	UpperCAmelCase_    			=     get_major_and_minor_from_version(_ipex_version      )
	if torch_major_and_minor != ipex_major_and_minor:
		warnings.warn(
		    F"Intel Extension for PyTorch {ipex_major_and_minor} needs to work with PyTorch {ipex_major_and_minor}.*,"
		    F" but PyTorch {_torch_version} is found. Please switch to the matching version and run again."      )
		return False
	return True



@lru_cache
def  __lowerCAmelCase (  A=False      ):
	if importlib.util.find_spec("torch"      ) is None or importlib.util.find_spec("torch_npu"      ) is None:
		return False

	import torch
	import torch_npu  # noqa: F401

	if check_device:
		try:
			# Will raise a RuntimeError if no NPU is found
			UpperCAmelCase_    			=     torch.npu.device_count()
			return torch.npu.is_available()
		except RuntimeError:
			return False
	return hasattr(A    ,       "npu"      ) and torch.npu.is_available()




@lru_cache
def  __lowerCAmelCase (  A=False      ):
	if not parse_flag_from_env("ACCELERATE_USE_XPU"    ,       default=A      ):
		return False
	if is_ipex_available():
		import torch

		if is_torch_version("<="    ,       "1.12"      ):
			return False
	else:
		return False

	import intel_extension_for_pytorch  # noqa: F401

	if check_device:
		try:
			# Will raise a RuntimeError if no XPU  is found
			UpperCAmelCase_    			=     torch.xpu.device_count()
			return torch.xpu.is_available()
		except RuntimeError:
			return False
	return hasattr(A    ,       "xpu"      ) and torch.xpu.is_available()