



"""simple docstring"""






import dataclasses
import re
import string
from typing import Any, Dict, Iterator, List, Mapping, Optional, Sequence, Tuple

import numpy as np

from . import residue_constants


__snake_case							:     int   =					Mapping[str, np.ndarray]
__snake_case							:     Union[str, Any]   =					Mapping[str, Any]  # Is a nested dict.
__snake_case							:     Any   =					0.01



@dataclasses.dataclass(frozen=__SCREAMING_SNAKE_CASE							)
class     A__     :




	'''simple docstring'''





	SCREAMING_SNAKE_CASE					   =			42  # [num_res, num_atom_type, 3]

	# Amino-acid type for each residue represented as an integer between 0 and
	# 20, where 20 is 'X'.
	SCREAMING_SNAKE_CASE					   =			42  # [num_res]

	# Binary float mask to indicate presence of a particular atom. 1.0 if an atom
	# is present and 0.0 if not. This should be used for loss masking.
	SCREAMING_SNAKE_CASE					   =			42  # [num_res, num_atom_type]

	# Residue index as used in PDB. It is not necessarily continuous or 0-indexed.
	SCREAMING_SNAKE_CASE					   =			42  # [num_res]

	# B-factors, or temperature factors, of each residue (in sq. angstroms units),
	# representing the displacement of the residue from its ground truth mean
	# value.
	SCREAMING_SNAKE_CASE					   =			42  # [num_res, num_atom_type]

	# Chain indices for multi-chain predictions
	SCREAMING_SNAKE_CASE					   =			None

	# Optional remark about the protein. Included as a comment in output PDB
	# files
	SCREAMING_SNAKE_CASE					   =			None

	# Templates used to generate this protein (prediction-only)
	SCREAMING_SNAKE_CASE					   =			None

	# Chain corresponding to each parent
	SCREAMING_SNAKE_CASE					   =			None






def     _lowercase       (						__snake_case			)		->     Protein:
			__lowerCAmelCase   :						List[Any]				= r"(\[[A-Z]+\]\n)"
			__lowerCAmelCase   :						List[str]				= [tag.strip() for tag in re.split(__snake_case      ,__snake_case			) if len(__snake_case			) > 0]
			__lowerCAmelCase   :						Iterator[Tuple[str, List[str]]]				= zip(tags[0::2]      ,[l.split("\n"			) for l in tags[1::2]]			)

			__lowerCAmelCase   :						List[str]				= ["N", "CA", "C"]
			__lowerCAmelCase   :						Dict				= None
			__lowerCAmelCase   :						Tuple				= None
			__lowerCAmelCase   :						Union[str, Any]				= None
			for g in groups:
						if "[PRIMARY]" == g[0]:
									__lowerCAmelCase   :						List[str]				= g[1][0].strip()
									for i in range(len(__snake_case			)			):
												if seq[i] not in residue_constants.restypes:
															__lowerCAmelCase   :						List[Any]				= "X"  # FIXME: strings are immutable
									__lowerCAmelCase   :						int				= np.array(
									    [residue_constants.restype_order.get(__snake_case      ,residue_constants.restype_num			) for res_symbol in seq]			)
						elif "[TERTIARY]" == g[0]:
									__lowerCAmelCase   :						List[List[float]]				= []
									for axis in range(3			):
												tertiary.append(list(map(__snake_case      ,g[1][axis].split()			)			)			)
									__lowerCAmelCase   :						Any				= np.array(__snake_case			)
									__lowerCAmelCase   :						Tuple				= np.zeros((len(tertiary[0]			) // 3, residue_constants.atom_type_num, 3)			).astype(np.floataa			)
									for i, atom in enumerate(__snake_case			):
												__lowerCAmelCase   :						Dict				= np.transpose(tertiary_np[:, i::3]			)
									atom_positions *= PICO_TO_ANGSTROM
						elif "[MASK]" == g[0]:
									__lowerCAmelCase   :						List[str]				= np.array(list(map({"-": 0, "+": 1}.get      ,g[1][0].strip()			)			)			)
									__lowerCAmelCase   :						List[Any]				= np.zeros(
									    (
									        len(__snake_case			),
									        residue_constants.atom_type_num,
									    )			).astype(np.floataa			)
									for i, atom in enumerate(__snake_case			):
												__lowerCAmelCase   :						List[Any]				= 1
									atom_mask *= mask[..., None]

			assert aatype is not None

			return Protein(
			    atom_positions=__snake_case      ,atom_mask=__snake_case      ,aatype=__snake_case      ,residue_index=np.arange(len(__snake_case			)			)      ,b_factors=__snake_case      ,)


def     _lowercase       (						__snake_case      ,__snake_case = 0			)		->     List[str]:
			__lowerCAmelCase   :						List[str]				= []

			__lowerCAmelCase   :						Optional[Any]				= prot.remark
			if remark is not None:
						pdb_headers.append(F"""REMARK {remark}"""			)

			__lowerCAmelCase   :						Tuple				= prot.parents
			__lowerCAmelCase   :						Dict				= prot.parents_chain_index
			if parents is not None and parents_chain_index is not None:
						__lowerCAmelCase   :						int				= [p for i, p in zip(__snake_case      ,__snake_case			) if i == chain_id]

			if parents is None or len(__snake_case			) == 0:
						__lowerCAmelCase   :						Any				= ["N/A"]

			pdb_headers.append(F"""PARENT {' '.join(__snake_case			)}"""			)

			return pdb_headers


def     _lowercase       (						__snake_case      ,__snake_case			)		->     str:
			__lowerCAmelCase   :						List[str]				= []
			__lowerCAmelCase   :						Optional[int]				= pdb_str.split("\n"			)

			__lowerCAmelCase   :						Any				= prot.remark
			if remark is not None:
						out_pdb_lines.append(F"""REMARK {remark}"""			)

			__lowerCAmelCase   :						List[List[str]]
			if prot.parents is not None and len(prot.parents			) > 0:
						__lowerCAmelCase   :						List[str]				= []
						if prot.parents_chain_index is not None:
									__lowerCAmelCase   :						Dict[str, List[str]]				= {}
									for p, i in zip(prot.parents      ,prot.parents_chain_index			):
												parent_dict.setdefault(str(__snake_case			)      ,[]			)
												parent_dict[str(__snake_case			)].append(__snake_case			)

									__lowerCAmelCase   :						Dict				= max([int(__snake_case			) for chain_idx in parent_dict]			)
									for i in range(max_idx + 1			):
												__lowerCAmelCase   :						Tuple				= parent_dict.get(str(__snake_case			)      ,["N/A"]			)
												parents_per_chain.append(__snake_case			)
						else:
									parents_per_chain.append(list(prot.parents			)			)
			else:
						__lowerCAmelCase   :						int				= [["N/A"]]

			def make_parent_line(__snake_case			) -> str:
						return F"""PARENT {' '.join(__snake_case			)}"""

			out_pdb_lines.append(make_parent_line(parents_per_chain[0]			)			)

			__lowerCAmelCase   :						int				= 0
			for i, l in enumerate(__snake_case			):
						if "PARENT" not in l and "REMARK" not in l:
									out_pdb_lines.append(__snake_case			)
						if "TER" in l and "END" not in lines[i + 1]:
									chain_counter += 1
									if not chain_counter >= len(__snake_case			):
												__lowerCAmelCase   :						List[Any]				= parents_per_chain[chain_counter]
									else:
												__lowerCAmelCase   :						List[str]				= ["N/A"]

									out_pdb_lines.append(make_parent_line(__snake_case			)			)

			return "\n".join(__snake_case			)


def     _lowercase       (						__snake_case			)		->     str:
			__lowerCAmelCase   :						int				= residue_constants.restypes + ["X"]

			def res_atoa(__snake_case			) -> str:
						return residue_constants.restype_atoa.get(restypes[r]      ,"UNK"			)

			__lowerCAmelCase   :						Dict				= residue_constants.atom_types

			__lowerCAmelCase   :						List[str]				= []

			__lowerCAmelCase   :						List[str]				= prot.atom_mask
			__lowerCAmelCase   :						Dict				= prot.aatype
			__lowerCAmelCase   :						Tuple				= prot.atom_positions
			__lowerCAmelCase   :						List[Any]				= prot.residue_index.astype(np.intaa			)
			__lowerCAmelCase   :						List[Any]				= prot.b_factors
			__lowerCAmelCase   :						Union[str, Any]				= prot.chain_index

			if np.any(aatype > residue_constants.restype_num			):
						raise ValueError("Invalid aatypes."			)

			__lowerCAmelCase   :						int				= get_pdb_headers(__snake_case			)
			if len(__snake_case			) > 0:
						pdb_lines.extend(__snake_case			)

			__lowerCAmelCase   :						List[Any]				= aatype.shape[0]
			__lowerCAmelCase   :						Optional[Any]				= 1
			__lowerCAmelCase   :						Optional[int]				= 0
			__lowerCAmelCase   :						Dict				= string.ascii_uppercase
			__lowerCAmelCase   :						Any				= None
			# Add all atom sites.
			for i in range(__snake_case			):
						__lowerCAmelCase   :						Union[str, Any]				= res_atoa(aatype[i]			)
						for atom_name, pos, mask, b_factor in zip(__snake_case      ,atom_positions[i]      ,atom_mask[i]      ,b_factors[i]			):
									if mask < 0.5:
												continue

									__lowerCAmelCase   :						str				= "ATOM"
									__lowerCAmelCase   :						Tuple				= atom_name if len(__snake_case			) == 4 else F""" {atom_name}"""
									__lowerCAmelCase   :						Union[str, Any]				= ""
									__lowerCAmelCase   :						Any				= ""
									__lowerCAmelCase   :						Dict				= 1.00
									__lowerCAmelCase   :						Any				= atom_name[0]  # Protein supports only C, N, O, S, this works.
									__lowerCAmelCase   :						Optional[Any]				= ""

									__lowerCAmelCase   :						Optional[Any]				= "A"
									if chain_index is not None:
												__lowerCAmelCase   :						List[str]				= chain_tags[chain_index[i]]

									# PDB is a columnar format, every space matters here!
									__lowerCAmelCase   :						Tuple				= (
									    F"""{record_type:<6}{atom_index:>5} {name:<4}{alt_loc:>1}"""
									    F"""{res_name_a:>3} {chain_tag:>1}"""
									    F"""{residue_index[i]:>4}{insertion_code:>1}   """
									    F"""{pos[0]:>8.3f}{pos[1]:>8.3f}{pos[2]:>8.3f}"""
									    F"""{occupancy:>6.2f}{b_factor:>6.2f}          """
									    F"""{element:>2}{charge:>2}"""
									)
									pdb_lines.append(__snake_case			)
									atom_index += 1

						__lowerCAmelCase   :						List[str]				= i == n - 1
						if chain_index is not None:
									if i != n - 1 and chain_index[i + 1] != prev_chain_index:
												__lowerCAmelCase   :						Optional[Any]				= True
												__lowerCAmelCase   :						Optional[Any]				= chain_index[i + 1]

						if should_terminate:
									# Close the chain.
									__lowerCAmelCase   :						Optional[Any]				= "TER"
									__lowerCAmelCase   :						List[Any]				= (
									    F"""{chain_end:<6}{atom_index:>5}      {res_atoa(aatype[i]			):>3} {chain_tag:>1}{residue_index[i]:>4}"""
									)
									pdb_lines.append(__snake_case			)
									atom_index += 1

									if i != n - 1:
												# "prev" is a misnomer here. This happens at the beginning of
												# each new chain.
												pdb_lines.extend(get_pdb_headers(__snake_case      ,__snake_case			)			)

			pdb_lines.append("END"			)
			pdb_lines.append(""			)
			return "\n".join(__snake_case			)


def     _lowercase       (						__snake_case			)		->     np.ndarray:
			return residue_constants.STANDARD_ATOM_MASK[prot.aatype]





def     _lowercase       (						__snake_case      ,__snake_case      ,__snake_case = None      ,__snake_case = None      ,__snake_case = None      ,__snake_case = None      ,__snake_case = None      ,)		->     Protein:
			return Protein(
			    aatype=features["aatype"]      ,atom_positions=result["final_atom_positions"]      ,atom_mask=result["final_atom_mask"]      ,residue_index=features["residue_index"] + 1      ,b_factors=b_factors if b_factors is not None else np.zeros_like(result["final_atom_mask"]			)      ,chain_index=__snake_case      ,remark=__snake_case      ,parents=__snake_case      ,parents_chain_index=__snake_case      ,)




"""simple docstring"""






import itertools
import random
import unittest

import numpy as np

from transformers import is_speech_available
from transformers.testing_utils import require_torch, require_torchaudio

from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin


if is_speech_available():
	from transformers import SpeechaTextFeatureExtractor

__snake_case							:     Union[str, Any]   =					random.Random()


def     _lowercase       (						__snake_case      ,__snake_case=1.0      ,__snake_case=None      ,__snake_case=None			)		->     List[Any]:
			if rng is None:
						__lowerCAmelCase   :						Dict				= global_rng

			__lowerCAmelCase   :						Tuple				= []
			for batch_idx in range(shape[0]			):
						values.append([]			)
						for _ in range(shape[1]			):
									values[-1].append(rng.random() * scale			)

			return values



@require_torch
@require_torchaudio
class     A__     (						unittest.TestCase							):




	'''simple docstring'''





	def __init__(  self:	Optional[Any] ,    _SCREAMING_SNAKE_CASE:	Any ,    _SCREAMING_SNAKE_CASE:	List[Any]=7 ,    _SCREAMING_SNAKE_CASE:	int=400 ,    _SCREAMING_SNAKE_CASE:	List[str]=2000 ,    _SCREAMING_SNAKE_CASE:	Optional[Any]=24 ,    _SCREAMING_SNAKE_CASE:	Dict=24 ,    _SCREAMING_SNAKE_CASE:	Optional[int]=0.0 ,    _SCREAMING_SNAKE_CASE:	Any=1_6000 ,    _SCREAMING_SNAKE_CASE:	int=True ,    _SCREAMING_SNAKE_CASE:	Union[str, Any]=True ,    )       -> List[Any]:

				"""simple docstring"""

				__lowerCAmelCase   :						Any				= parent
				__lowerCAmelCase   :						str				= batch_size
				__lowerCAmelCase   :						List[str]				= min_seq_length
				__lowerCAmelCase   :						Any				= max_seq_length
				__lowerCAmelCase   :						Dict				= (self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
				__lowerCAmelCase   :						Union[str, Any]				= feature_size
				__lowerCAmelCase   :						int				= num_mel_bins
				__lowerCAmelCase   :						Optional[Any]				= padding_value
				__lowerCAmelCase   :						List[Any]				= sampling_rate
				__lowerCAmelCase   :						Dict				= return_attention_mask
				__lowerCAmelCase   :						int				= do_normalize

	def 							_SCREAMING_SNAKE_CASE     (  self:	Any)       -> Optional[int]:

				"""simple docstring"""

				return {
				    "feature_size": self.feature_size,
				    "num_mel_bins": self.num_mel_bins,
				    "padding_value": self.padding_value,
				    "sampling_rate": self.sampling_rate,
				    "return_attention_mask": self.return_attention_mask,
				    "do_normalize": self.do_normalize,
				}







	def 							_SCREAMING_SNAKE_CASE     (  self:	Tuple ,    _SCREAMING_SNAKE_CASE:	Tuple=False ,    _SCREAMING_SNAKE_CASE:	int=False)       -> Optional[int]:

				"""simple docstring"""

				def _flatten(_SCREAMING_SNAKE_CASE:	Optional[Any]):
							return list(itertools.chain(*_SCREAMING_SNAKE_CASE))

				if equal_length:
							__lowerCAmelCase   :						Tuple				= [floats_list((self.max_seq_length, self.feature_size)) for _ in range(self.batch_size)]
				else:
							# make sure that inputs increase in size
							__lowerCAmelCase   :						List[Any]				= [
							    floats_list((x, self.feature_size))
							    for x in range(self.min_seq_length ,    self.max_seq_length ,    self.seq_length_diff)
							]
				if numpify:
							__lowerCAmelCase   :						Any				= [np.asarray(_SCREAMING_SNAKE_CASE) for x in speech_inputs]
				return speech_inputs






@require_torch
@require_torchaudio
class     A__     (						__SCREAMING_SNAKE_CASE						,	unittest.TestCase							):




	'''simple docstring'''





	SCREAMING_SNAKE_CASE					   =			SpeechaTextFeatureExtractor if is_speech_available() else None

	def 							_SCREAMING_SNAKE_CASE     (  self:	List[Any])       -> Tuple:

				"""simple docstring"""

				__lowerCAmelCase   :						Tuple				= SpeechaTextFeatureExtractionTester(self)

	def 							_SCREAMING_SNAKE_CASE     (  self:	Optional[Any] ,    _SCREAMING_SNAKE_CASE:	Optional[Any])       -> str:

				"""simple docstring"""

				self.assertTrue(np.all(np.mean(_SCREAMING_SNAKE_CASE ,    axis=0) < 1e-3))
				self.assertTrue(np.all(np.abs(np.var(_SCREAMING_SNAKE_CASE ,    axis=0) - 1) < 1e-3))

	def 							_SCREAMING_SNAKE_CASE     (  self:	Union[str, Any])       -> int:

				"""simple docstring"""

				__lowerCAmelCase   :						Dict				= self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict())
				# create three inputs of length 800, 1000, and 1200
				__lowerCAmelCase   :						Tuple				= [floats_list((1, x))[0] for x in range(800 ,    1400 ,    200)]
				__lowerCAmelCase   :						Optional[int]				= [np.asarray(_SCREAMING_SNAKE_CASE) for speech_input in speech_inputs]

				# Test feature size
				__lowerCAmelCase   :						Optional[int]				= feature_extractor(_SCREAMING_SNAKE_CASE ,    padding=_SCREAMING_SNAKE_CASE ,    return_tensors="np").input_features
				self.assertTrue(input_features.ndim == 3)
				self.assertTrue(input_features.shape[-1] == feature_extractor.feature_size)

				# Test not batched input
				__lowerCAmelCase   :						Optional[Any]				= feature_extractor(speech_inputs[0] ,    return_tensors="np").input_features
				__lowerCAmelCase   :						Any				= feature_extractor(np_speech_inputs[0] ,    return_tensors="np").input_features
				self.assertTrue(np.allclose(_SCREAMING_SNAKE_CASE ,    _SCREAMING_SNAKE_CASE ,    atol=1e-3))

				# Test batched
				__lowerCAmelCase   :						Tuple				= feature_extractor(_SCREAMING_SNAKE_CASE ,    return_tensors="np").input_features
				__lowerCAmelCase   :						Tuple				= feature_extractor(_SCREAMING_SNAKE_CASE ,    return_tensors="np").input_features
				for enc_seq_a, enc_seq_a in zip(_SCREAMING_SNAKE_CASE ,    _SCREAMING_SNAKE_CASE):
							self.assertTrue(np.allclose(_SCREAMING_SNAKE_CASE ,    _SCREAMING_SNAKE_CASE ,    atol=1e-3))

				# Test 2-D numpy arrays are batched.
				__lowerCAmelCase   :						List[str]				= [floats_list((1, x))[0] for x in (800, 800, 800)]
				__lowerCAmelCase   :						Dict				= np.asarray(_SCREAMING_SNAKE_CASE)
				__lowerCAmelCase   :						Optional[int]				= feature_extractor(_SCREAMING_SNAKE_CASE ,    return_tensors="np").input_features
				__lowerCAmelCase   :						Optional[Any]				= feature_extractor(_SCREAMING_SNAKE_CASE ,    return_tensors="np").input_features
				for enc_seq_a, enc_seq_a in zip(_SCREAMING_SNAKE_CASE ,    _SCREAMING_SNAKE_CASE):
							self.assertTrue(np.allclose(_SCREAMING_SNAKE_CASE ,    _SCREAMING_SNAKE_CASE ,    atol=1e-3))

	def 							_SCREAMING_SNAKE_CASE     (  self:	Union[str, Any])       -> List[Any]:

				"""simple docstring"""

				__lowerCAmelCase   :						Tuple				= self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict())
				__lowerCAmelCase   :						Tuple				= [floats_list((1, x))[0] for x in range(800 ,    1400 ,    200)]

				__lowerCAmelCase   :						Optional[Any]				= ["longest", "max_length", "do_not_pad"]
				__lowerCAmelCase   :						str				= [None, 16, None]
				for max_length, padding in zip(_SCREAMING_SNAKE_CASE ,    _SCREAMING_SNAKE_CASE):
							__lowerCAmelCase   :						str				= feature_extractor(
							    _SCREAMING_SNAKE_CASE ,    padding=_SCREAMING_SNAKE_CASE ,    max_length=_SCREAMING_SNAKE_CASE ,    return_attention_mask=_SCREAMING_SNAKE_CASE)
							__lowerCAmelCase   :						Optional[Any]				= inputs.input_features
							__lowerCAmelCase   :						Optional[Any]				= inputs.attention_mask
							__lowerCAmelCase   :						Tuple				= [np.sum(_SCREAMING_SNAKE_CASE) for x in attention_mask]

							self._check_zero_mean_unit_variance(input_features[0][: fbank_feat_lengths[0]])
							self._check_zero_mean_unit_variance(input_features[1][: fbank_feat_lengths[1]])
							self._check_zero_mean_unit_variance(input_features[2][: fbank_feat_lengths[2]])

	def 							_SCREAMING_SNAKE_CASE     (  self:	Any)       -> Optional[Any]:

				"""simple docstring"""

				__lowerCAmelCase   :						str				= self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict())
				__lowerCAmelCase   :						Any				= [floats_list((1, x))[0] for x in range(800 ,    1400 ,    200)]

				__lowerCAmelCase   :						Dict				= ["longest", "max_length", "do_not_pad"]
				__lowerCAmelCase   :						List[Any]				= [None, 16, None]
				for max_length, padding in zip(_SCREAMING_SNAKE_CASE ,    _SCREAMING_SNAKE_CASE):
							__lowerCAmelCase   :						List[str]				= feature_extractor(
							    _SCREAMING_SNAKE_CASE ,    max_length=_SCREAMING_SNAKE_CASE ,    padding=_SCREAMING_SNAKE_CASE ,    return_tensors="np" ,    return_attention_mask=_SCREAMING_SNAKE_CASE)
							__lowerCAmelCase   :						List[str]				= inputs.input_features
							__lowerCAmelCase   :						Dict				= inputs.attention_mask
							__lowerCAmelCase   :						Dict				= [np.sum(_SCREAMING_SNAKE_CASE) for x in attention_mask]

							self._check_zero_mean_unit_variance(input_features[0][: fbank_feat_lengths[0]])
							self.assertTrue(input_features[0][fbank_feat_lengths[0] :].sum() < 1e-6)
							self._check_zero_mean_unit_variance(input_features[1][: fbank_feat_lengths[1]])
							self.assertTrue(input_features[0][fbank_feat_lengths[1] :].sum() < 1e-6)
							self._check_zero_mean_unit_variance(input_features[2][: fbank_feat_lengths[2]])

	def 							_SCREAMING_SNAKE_CASE     (  self:	str)       -> Any:

				"""simple docstring"""

				__lowerCAmelCase   :						str				= self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict())
				__lowerCAmelCase   :						str				= [floats_list((1, x))[0] for x in range(800 ,    1400 ,    200)]
				__lowerCAmelCase   :						str				= feature_extractor(
				    _SCREAMING_SNAKE_CASE ,    padding="max_length" ,    max_length=4 ,    truncation=_SCREAMING_SNAKE_CASE ,    return_tensors="np" ,    return_attention_mask=_SCREAMING_SNAKE_CASE ,    )
				__lowerCAmelCase   :						List[str]				= inputs.input_features
				__lowerCAmelCase   :						Dict				= inputs.attention_mask
				__lowerCAmelCase   :						Any				= np.sum(attention_mask == 1 ,    axis=1)

				self._check_zero_mean_unit_variance(input_features[0, : fbank_feat_lengths[0]])
				self._check_zero_mean_unit_variance(input_features[1])
				self._check_zero_mean_unit_variance(input_features[2])

	def 							_SCREAMING_SNAKE_CASE     (  self:	int)       -> List[str]:

				"""simple docstring"""

				__lowerCAmelCase   :						Union[str, Any]				= self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict())
				__lowerCAmelCase   :						List[Any]				= [floats_list((1, x))[0] for x in range(800 ,    1400 ,    200)]
				__lowerCAmelCase   :						Any				= feature_extractor(
				    _SCREAMING_SNAKE_CASE ,    padding="longest" ,    max_length=4 ,    truncation=_SCREAMING_SNAKE_CASE ,    return_tensors="np" ,    return_attention_mask=_SCREAMING_SNAKE_CASE ,    )
				__lowerCAmelCase   :						List[str]				= inputs.input_features
				__lowerCAmelCase   :						Optional[Any]				= inputs.attention_mask
				__lowerCAmelCase   :						Optional[Any]				= np.sum(attention_mask == 1 ,    axis=1)

				self._check_zero_mean_unit_variance(input_features[0, : fbank_feat_lengths[0]])
				self._check_zero_mean_unit_variance(input_features[1, : fbank_feat_lengths[1]])
				self._check_zero_mean_unit_variance(input_features[2])

				# make sure that if max_length < longest -> then pad to max_length
				self.assertEqual(input_features.shape ,    (3, 4, 24))

				__lowerCAmelCase   :						List[str]				= [floats_list((1, x))[0] for x in range(800 ,    1400 ,    200)]
				__lowerCAmelCase   :						List[str]				= feature_extractor(
				    _SCREAMING_SNAKE_CASE ,    padding="longest" ,    max_length=16 ,    truncation=_SCREAMING_SNAKE_CASE ,    return_tensors="np" ,    return_attention_mask=_SCREAMING_SNAKE_CASE ,    )
				__lowerCAmelCase   :						Optional[Any]				= inputs.input_features
				__lowerCAmelCase   :						Optional[int]				= inputs.attention_mask
				__lowerCAmelCase   :						str				= np.sum(attention_mask == 1 ,    axis=1)

				self._check_zero_mean_unit_variance(input_features[0, : fbank_feat_lengths[0]])
				self._check_zero_mean_unit_variance(input_features[1, : fbank_feat_lengths[1]])
				self._check_zero_mean_unit_variance(input_features[2])

				# make sure that if max_length < longest -> then pad to max_length
				self.assertEqual(input_features.shape ,    (3, 6, 24))

	def 							_SCREAMING_SNAKE_CASE     (  self:	Any)       -> Dict:

				"""simple docstring"""

				import torch

				__lowerCAmelCase   :						Dict				= self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict())
				__lowerCAmelCase   :						List[str]				= np.random.rand(100 ,    32).astype(np.floataa)
				__lowerCAmelCase   :						List[Any]				= np_speech_inputs.tolist()

				for inputs in [py_speech_inputs, np_speech_inputs]:
							__lowerCAmelCase   :						Any				= feature_extractor.pad([{"input_features": inputs}] ,    return_tensors="np")
							self.assertTrue(np_processed.input_features.dtype == np.floataa)
							__lowerCAmelCase   :						List[Any]				= feature_extractor.pad([{"input_features": inputs}] ,    return_tensors="pt")
							self.assertTrue(pt_processed.input_features.dtype == torch.floataa)

	def 							_SCREAMING_SNAKE_CASE     (  self:	str ,    _SCREAMING_SNAKE_CASE:	List[Any])       -> Optional[Any]:

				"""simple docstring"""

				from datasets import load_dataset

				__lowerCAmelCase   :						Any				= load_dataset("hf-internal-testing/librispeech_asr_dummy" ,    "clean" ,    split="validation")
				# automatic decoding with librispeech
				__lowerCAmelCase   :						List[Any]				= ds.sort("id").select(range(_SCREAMING_SNAKE_CASE))[:num_samples]["audio"]

				return [x["array"] for x in speech_samples]







	def 							_SCREAMING_SNAKE_CASE     (  self:	List[str])       -> Any:

				"""simple docstring"""

				__lowerCAmelCase   :						str				= np.array([
				    -1.5745, -1.7713, -1.7020, -1.6069, -1.2250, -1.1105, -0.9072, -0.8241,
				    -1.2310, -0.8098, -0.3320, -0.4101, -0.7985, -0.4996, -0.8213, -0.9128,
				    -1.0420, -1.1286, -1.0440, -0.7999, -0.8405, -1.2275, -1.5443, -1.4625,
				])
				# fmt: on

				__lowerCAmelCase   :						str				= self._load_datasamples(1)
				__lowerCAmelCase   :						Any				= self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict())
				__lowerCAmelCase   :						List[str]				= feature_extractor(_SCREAMING_SNAKE_CASE ,    return_tensors="pt").input_features
				self.assertEquals(input_features.shape ,    (1, 584, 24))
				self.assertTrue(np.allclose(input_features[0, 0, :30] ,    _SCREAMING_SNAKE_CASE ,    atol=1e-4))