

import unittest

from transformers import EsmConfig, is_torch_available
from transformers.testing_utils import TestCasePlus, require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
  import torch

  from transformers.models.esm.modeling_esmfold import EsmForProteinFolding







class 				a__				:







  """simple docstring"""




  def __init__(	self			:       Dict , UpperCAmelCase__			:       Optional[Any] , UpperCAmelCase__			:       Any=1_3 , UpperCAmelCase__			:       Dict=7 , UpperCAmelCase__			:       str=False , UpperCAmelCase__			:       Any=True , UpperCAmelCase__			:       List[Any]=False , UpperCAmelCase__			:       List[str]=False , UpperCAmelCase__			:       List[Any]=1_9 , UpperCAmelCase__			:       Tuple=3_2 , UpperCAmelCase__			:       Any=5 , UpperCAmelCase__			:       Dict=4 , UpperCAmelCase__			:       List[str]=3_7 , UpperCAmelCase__			:       Tuple="gelu" , UpperCAmelCase__			:       Union[str, Any]=0.1 , UpperCAmelCase__			:       int=0.1 , UpperCAmelCase__			:       str=5_1_2 , UpperCAmelCase__			:       Any=1_6 , UpperCAmelCase__			:       Any=2 , UpperCAmelCase__			:       Optional[Any]=0.02 , UpperCAmelCase__			:       str=3 , UpperCAmelCase__			:       Tuple=4 , UpperCAmelCase__			:       str=None , )    ->Optional[int]:
        """simple docstring"""







        SCREAMING_SNAKE_CASE       :					Optional[int]        =      parent
        SCREAMING_SNAKE_CASE       :					Optional[int]        =      batch_size
        SCREAMING_SNAKE_CASE       :					Any        =      seq_length
        SCREAMING_SNAKE_CASE       :					Tuple        =      is_training
        SCREAMING_SNAKE_CASE       :					int        =      use_input_mask
        SCREAMING_SNAKE_CASE       :					Optional[Any]        =      use_token_type_ids
        SCREAMING_SNAKE_CASE       :					List[str]        =      use_labels
        SCREAMING_SNAKE_CASE       :					Optional[int]        =      vocab_size
        SCREAMING_SNAKE_CASE       :					Optional[int]        =      hidden_size
        SCREAMING_SNAKE_CASE       :					Any        =      num_hidden_layers
        SCREAMING_SNAKE_CASE       :					Optional[Any]        =      num_attention_heads
        SCREAMING_SNAKE_CASE       :					Union[str, Any]        =      intermediate_size
        SCREAMING_SNAKE_CASE       :					Tuple        =      hidden_act
        SCREAMING_SNAKE_CASE       :					Optional[Any]        =      hidden_dropout_prob
        SCREAMING_SNAKE_CASE       :					Tuple        =      attention_probs_dropout_prob
        SCREAMING_SNAKE_CASE       :					List[Any]        =      max_position_embeddings
        SCREAMING_SNAKE_CASE       :					List[Any]        =      type_vocab_size
        SCREAMING_SNAKE_CASE       :					Tuple        =      type_sequence_label_size
        SCREAMING_SNAKE_CASE       :					int        =      initializer_range
        SCREAMING_SNAKE_CASE       :					Dict        =      num_labels
        SCREAMING_SNAKE_CASE       :					List[str]        =      num_choices
        SCREAMING_SNAKE_CASE       :					str        =      scope


  def        _lowercase					(	self			:       Tuple						)    ->str:
        """simple docstring"""







        SCREAMING_SNAKE_CASE       :					str        =      ids_tensor([self.batch_size, self.seq_length] , self.vocab_size						)

        SCREAMING_SNAKE_CASE       :					str        =      None
        if self.use_input_mask:
              SCREAMING_SNAKE_CASE       :					List[str]        =      random_attention_mask([self.batch_size, self.seq_length]						)

        SCREAMING_SNAKE_CASE       :					Optional[int]        =      None
        SCREAMING_SNAKE_CASE       :					int        =      None
        SCREAMING_SNAKE_CASE       :					Tuple        =      None
        if self.use_labels:
              SCREAMING_SNAKE_CASE       :					str        =      ids_tensor([self.batch_size] , self.type_sequence_label_size						)
              SCREAMING_SNAKE_CASE       :					Any        =      ids_tensor([self.batch_size, self.seq_length] , self.num_labels						)
              SCREAMING_SNAKE_CASE       :					str        =      ids_tensor([self.batch_size] , self.num_choices						)

        SCREAMING_SNAKE_CASE       :					Union[str, Any]        =      self.get_config()

        return config, input_ids, input_mask, sequence_labels, token_labels, choice_labels


  def        _lowercase					(	self			:       Any						)    ->str:
        """simple docstring"""







        SCREAMING_SNAKE_CASE       :					Optional[Any]        =      EsmConfig(
            vocab_size=3_3 , hidden_size=self.hidden_size , pad_token_id=1 , num_hidden_layers=self.num_hidden_layers , num_attention_heads=self.num_attention_heads , intermediate_size=self.intermediate_size , hidden_act=self.hidden_act , hidden_dropout_prob=self.hidden_dropout_prob , attention_probs_dropout_prob=self.attention_probs_dropout_prob , max_position_embeddings=self.max_position_embeddings , type_vocab_size=self.type_vocab_size , initializer_range=self.initializer_range , is_folding_model=A_ , esmfold_config={"""trunk""": {"""num_blocks""": 2}, """fp16_esm""": False} , )
        return config


  def        _lowercase					(	self			:       Optional[int] , UpperCAmelCase__			:       Any , UpperCAmelCase__			:       Optional[int] , UpperCAmelCase__			:       Any , UpperCAmelCase__			:       Dict , UpperCAmelCase__			:       Union[str, Any] , UpperCAmelCase__			:       Optional[Any]						)    ->str:
        """simple docstring"""







        SCREAMING_SNAKE_CASE       :					Dict        =      EsmForProteinFolding(config=A_						).float()
        model.to(A_						)
        model.eval()
        SCREAMING_SNAKE_CASE       :					Union[str, Any]        =      model(A_ , attention_mask=A_						)
        SCREAMING_SNAKE_CASE       :					Any        =      model(A_						)
        SCREAMING_SNAKE_CASE       :					Optional[Any]        =      model(A_						)

        self.parent.assertEqual(result.positions.shape , (8, self.batch_size, self.seq_length, 1_4, 3)						)
        self.parent.assertEqual(result.angles.shape , (8, self.batch_size, self.seq_length, 7, 2)						)




  def        _lowercase					(	self			:       Any						)    ->str:
        """simple docstring"""







        SCREAMING_SNAKE_CASE       :					List[Any]        =      self.prepare_config_and_inputs()
        (
            SCREAMING_SNAKE_CASE							
        )       :					Union[str, Any]        =      config_and_inputs
        SCREAMING_SNAKE_CASE       :					List[Any]        =      {'''input_ids''': input_ids, '''attention_mask''': input_mask}
        return config, inputs_dict







@require_torch
class 				a__				(      _UpperCAmelCase		,	_UpperCAmelCase		,	unittest.TestCase				):







  """simple docstring"""




  UpperCAmelCase__					:       Any					=False

  UpperCAmelCase__					:       Union[str, Any]					=(EsmForProteinFolding,) if is_torch_available() else ()
  UpperCAmelCase__					:       List[str]					=()
  UpperCAmelCase__					:       Union[str, Any]					={} if is_torch_available() else {}
  UpperCAmelCase__					:       str					=False


  def        _lowercase					(	self			:       int						)    ->Optional[int]:
        """simple docstring"""







        SCREAMING_SNAKE_CASE       :					List[str]        =      EsmFoldModelTester(self						)
        SCREAMING_SNAKE_CASE       :					int        =      ConfigTester(self , config_class=A_ , hidden_size=3_7						)


  def        _lowercase					(	self			:       Optional[Any]						)    ->List[str]:
        """simple docstring"""







        self.config_tester.run_common_tests()


  def        _lowercase					(	self			:       str						)    ->int:
        """simple docstring"""







        SCREAMING_SNAKE_CASE       :					List[str]        =      self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*A_						)


  @unittest.skip("""Does not support attention outputs"""						)
  def        _lowercase					(	self			:       Optional[int]						)    ->Optional[Any]:
        """simple docstring"""







        pass


  @unittest.skip
  def        _lowercase					(	self			:       Tuple						)    ->Dict:
        """simple docstring"""







        pass


  @unittest.skip("""Esm does not support embedding resizing"""						)
  def        _lowercase					(	self			:       str						)    ->int:
        """simple docstring"""







        pass


  @unittest.skip("""Esm does not support embedding resizing"""						)
  def        _lowercase					(	self			:       str						)    ->Optional[Any]:
        """simple docstring"""







        pass


  @unittest.skip("""ESMFold does not support passing input embeds!"""						)
  def        _lowercase					(	self			:       Tuple						)    ->Optional[Any]:
        """simple docstring"""







        pass


  @unittest.skip("""ESMFold does not support head pruning."""						)
  def        _lowercase					(	self			:       Any						)    ->Union[str, Any]:
        """simple docstring"""







        pass


  @unittest.skip("""ESMFold does not support head pruning."""						)
  def        _lowercase					(	self			:       List[Any]						)    ->Optional[int]:
        """simple docstring"""







        pass


  @unittest.skip("""ESMFold does not support head pruning."""						)
  def        _lowercase					(	self			:       Optional[int]						)    ->Optional[Any]:
        """simple docstring"""







        pass


  @unittest.skip("""ESMFold does not support head pruning."""						)
  def        _lowercase					(	self			:       List[Any]						)    ->Optional[Any]:
        """simple docstring"""







        pass


  @unittest.skip("""ESMFold does not support head pruning."""						)
  def        _lowercase					(	self			:       Dict						)    ->List[Any]:
        """simple docstring"""







        pass


  @unittest.skip("""ESMFold does not output hidden states in the normal way."""						)
  def        _lowercase					(	self			:       Any						)    ->Any:
        """simple docstring"""







        pass


  @unittest.skip("""ESMfold does not output hidden states in the normal way."""						)
  def        _lowercase					(	self			:       Dict						)    ->str:
        """simple docstring"""







        pass


  @unittest.skip("""ESMFold only has one output format."""						)
  def        _lowercase					(	self			:       List[Any]						)    ->Dict:
        """simple docstring"""







        pass


  @unittest.skip("""This test doesn\'t work for ESMFold and doesn\'t test core functionality"""						)
  def        _lowercase					(	self			:       str						)    ->Optional[Any]:
        """simple docstring"""







        pass


  @unittest.skip("""ESMFold does not support input chunking."""						)
  def        _lowercase					(	self			:       Union[str, Any]						)    ->List[str]:
        """simple docstring"""







        pass


  @unittest.skip("""ESMFold doesn\'t respect you and it certainly doesn\'t respect your initialization arguments."""						)
  def        _lowercase					(	self			:       Any						)    ->Optional[int]:
        """simple docstring"""







        pass


  @unittest.skip("""ESMFold doesn\'t support torchscript compilation."""						)
  def        _lowercase					(	self			:       int						)    ->Any:
        """simple docstring"""







        pass


  @unittest.skip("""ESMFold doesn\'t support torchscript compilation."""						)
  def        _lowercase					(	self			:       Union[str, Any]						)    ->Union[str, Any]:
        """simple docstring"""







        pass


  @unittest.skip("""ESMFold doesn\'t support torchscript compilation."""						)
  def        _lowercase					(	self			:       Union[str, Any]						)    ->Dict:
        """simple docstring"""







        pass


  @unittest.skip("""ESMFold doesn\'t support data parallel."""						)
  def        _lowercase					(	self			:       Tuple						)    ->Tuple:
        """simple docstring"""







        pass




  @unittest.skip("""Will be fixed soon by reducing the size of the model used for common tests."""						)
  def        _lowercase					(	self			:       Any						)    ->List[str]:
        """simple docstring"""







        pass







@require_torch
class 				a__				(      _UpperCAmelCase				):







  """simple docstring"""




  @slow
  def        _lowercase					(	self			:       Optional[Any]						)    ->List[str]:
        """simple docstring"""







        SCREAMING_SNAKE_CASE       :					Dict        =      EsmForProteinFolding.from_pretrained("""facebook/esmfold_v1"""						).float()
        model.eval()
        SCREAMING_SNAKE_CASE       :					Optional[Any]        =      torch.tensor([[0, 6, 4, 1_3, 5, 4, 1_6, 1_2, 1_1, 7, 2]]						)
        SCREAMING_SNAKE_CASE       :					List[str]        =      model(A_						)['''positions''']
        SCREAMING_SNAKE_CASE       :					Any        =      torch.tensor([2.58_28, 0.79_93, -10.93_34] , dtype=torch.floataa						)
        self.assertTrue(torch.allclose(position_outputs[0, 0, 0, 0] , A_ , atol=1e-4						)						)







import itertools
import os
import random
import tempfile
import unittest

import numpy as np
from datasets import load_dataset

from transformers import is_speech_available
from transformers.testing_utils import check_json_file_has_correct_format, require_torch, require_torchaudio
from transformers.utils.import_utils import is_torch_available

from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin


if is_speech_available():
 from transformers import WhisperFeatureExtractor

if is_torch_available():
 import torch

_UpperCamelCase 			=		random.Random()







def 		_lowercase (     lowercase__   ,	lowercase__=1.0   ,	lowercase__=None   ,	lowercase__=None						):
      if rng is None:
            __lowerCAmelCase					:						Any					=					global_rng

      __lowerCAmelCase					:						str					=					[]
      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   __lowercase      (unittest.TestCase ):
 def __init__(							self      ,							A_      ,							A_=7      ,							A_=400      ,							A_=2000      ,							A_=10      ,							A_=160      ,							A_=8      ,							A_=0.0      ,							A_=4000      ,							A_=False      ,							A_=True      ,							)					->List[str]:



       '''simple docstring'''





       __lowerCAmelCase					:						Optional[int]					=					parent
       __lowerCAmelCase					:						Dict					=					batch_size
       __lowerCAmelCase					:						str					=					min_seq_length
       __lowerCAmelCase					:						int					=					max_seq_length
       __lowerCAmelCase					:						Any					=					(self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
       __lowerCAmelCase					:						Any					=					padding_value
       __lowerCAmelCase					:						str					=					sampling_rate
       __lowerCAmelCase					:						Optional[Any]					=					return_attention_mask
       __lowerCAmelCase					:						Optional[Any]					=					do_normalize
       __lowerCAmelCase					:						Optional[Any]					=					feature_size
       __lowerCAmelCase					:						Optional[int]					=					chunk_length
       __lowerCAmelCase					:						Optional[Any]					=					hop_length
 def 	UpperCamelCase__  (							self					)					->Optional[Any]:



       '''simple docstring'''





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





 def 	UpperCamelCase__  (							self      ,							A_=False      ,							A_=False					)					->Optional[Any]:



       '''simple docstring'''





       def _flatten(A_					):
             return list(itertools.chain(*A_					)					)

       if equal_length:
             __lowerCAmelCase					:						str					=					[floats_list((self.max_seq_length, self.feature_size)					) for _ in range(self.batch_size					)]
       else:
             # make sure that inputs increase in size
             __lowerCAmelCase					:						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					:						Optional[Any]					=					[np.asarray(A_					) for x in speech_inputs]
       return speech_inputs







@require_torch
@require_torchaudio
class   __lowercase      (_UpperCAmelCase		,   unittest.TestCase ):
 _UpperCamelCase			  =  WhisperFeatureExtractor if is_speech_available() else None
 def 	UpperCamelCase__  (							self					)					->Optional[int]:



       '''simple docstring'''





       __lowerCAmelCase					:						Tuple					=					WhisperFeatureExtractionTester(self					)
 def 	UpperCamelCase__  (							self					)					->int:



       '''simple docstring'''





       __lowerCAmelCase					:						str					=					self.feature_extraction_class(**self.feat_extract_dict					)

       with tempfile.TemporaryDirectory() as tmpdirname:
             __lowerCAmelCase					:						List[str]					=					feat_extract_first.save_pretrained(A_					)[0]
             check_json_file_has_correct_format(A_					)
             __lowerCAmelCase					:						int					=					self.feature_extraction_class.from_pretrained(A_					)

       __lowerCAmelCase					:						Dict					=					feat_extract_first.to_dict()
       __lowerCAmelCase					:						Union[str, Any]					=					feat_extract_second.to_dict()
       __lowerCAmelCase					:						Union[str, Any]					=					feat_extract_first.mel_filters
       __lowerCAmelCase					:						Dict					=					feat_extract_second.mel_filters
       self.assertTrue(np.allclose(A_      ,							A_					)					)
       self.assertEqual(A_      ,							A_					)
 def 	UpperCamelCase__  (							self					)					->str:



       '''simple docstring'''





       __lowerCAmelCase					:						str					=					self.feature_extraction_class(**self.feat_extract_dict					)

       with tempfile.TemporaryDirectory() as tmpdirname:
             __lowerCAmelCase					:						Union[str, Any]					=					os.path.join(A_      ,							'''feat_extract.json'''					)
             feat_extract_first.to_json_file(A_					)
             __lowerCAmelCase					:						List[str]					=					self.feature_extraction_class.from_json_file(A_					)

       __lowerCAmelCase					:						List[str]					=					feat_extract_first.to_dict()
       __lowerCAmelCase					:						Tuple					=					feat_extract_second.to_dict()
       __lowerCAmelCase					:						Any					=					feat_extract_first.mel_filters
       __lowerCAmelCase					:						List[str]					=					feat_extract_second.mel_filters
       self.assertTrue(np.allclose(A_      ,							A_					)					)
       self.assertEqual(A_      ,							A_					)
 def 	UpperCamelCase__  (							self					)					->List[Any]:



       '''simple docstring'''





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

       # Test feature size
       __lowerCAmelCase					:						Tuple					=					feature_extractor(A_      ,							padding='''max_length'''      ,							return_tensors='''np'''					).input_features
       self.assertTrue(input_features.ndim == 3					)
       self.assertTrue(input_features.shape[-1] == feature_extractor.nb_max_frames					)
       self.assertTrue(input_features.shape[-2] == feature_extractor.feature_size					)

       # Test not batched input
       __lowerCAmelCase					:						Dict					=					feature_extractor(speech_inputs[0]      ,							return_tensors='''np'''					).input_features
       __lowerCAmelCase					:						List[str]					=					feature_extractor(np_speech_inputs[0]      ,							return_tensors='''np'''					).input_features
       self.assertTrue(np.allclose(A_      ,							A_      ,							atol=1e-3					)					)

       # Test batched
       __lowerCAmelCase					:						Union[str, Any]					=					feature_extractor(A_      ,							return_tensors='''np'''					).input_features
       __lowerCAmelCase					:						List[Any]					=					feature_extractor(A_      ,							return_tensors='''np'''					).input_features
       for enc_seq_a, enc_seq_a in zip(A_      ,							A_					):
             self.assertTrue(np.allclose(A_      ,							A_      ,							atol=1e-3					)					)

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

       # Test truncation required
       __lowerCAmelCase					:						Optional[int]					=					[floats_list((1, x)					)[0] for x in range(200      ,							(feature_extractor.n_samples + 500)      ,							200					)]
       __lowerCAmelCase					:						Dict					=					[np.asarray(A_					) for speech_input in speech_inputs]

       __lowerCAmelCase					:						Tuple					=					[x[: feature_extractor.n_samples] for x in speech_inputs]
       __lowerCAmelCase					:						Optional[int]					=					[np.asarray(A_					) for speech_input in speech_inputs_truncated]

       __lowerCAmelCase					:						Any					=					feature_extractor(A_      ,							return_tensors='''np'''					).input_features
       __lowerCAmelCase					:						List[str]					=					feature_extractor(A_      ,							return_tensors='''np'''					).input_features
       for enc_seq_a, enc_seq_a in zip(A_      ,							A_					):
             self.assertTrue(np.allclose(A_      ,							A_      ,							atol=1e-3					)					)
 def 	UpperCamelCase__  (							self					)					->Dict:



       '''simple docstring'''





       import torch

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

       for inputs in [py_speech_inputs, np_speech_inputs]:
             __lowerCAmelCase					:						Tuple					=					feature_extractor.pad([{'''input_features''': inputs}]      ,							return_tensors='''np'''					)
             self.assertTrue(np_processed.input_features.dtype == np.floataa					)
             __lowerCAmelCase					:						int					=					feature_extractor.pad([{'''input_features''': inputs}]      ,							return_tensors='''pt'''					)
             self.assertTrue(pt_processed.input_features.dtype == torch.floataa					)
 def 	UpperCamelCase__  (							self      ,							A_					)					->str:



       '''simple docstring'''





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

       return [x["array"] for x in speech_samples]
 def 	UpperCamelCase__  (							self					)					->int:



       '''simple docstring'''





       __lowerCAmelCase					:						Optional[int]					=					torch.tensor(
           [
               0.1_193, -0.0_946, -0.1_098, -0.0_196, 0.0_225, -0.0_690, -0.1_736, 0.0_951,
               0.0_971, -0.0_817, -0.0_702, 0.0_162, 0.0_260, 0.0_017, -0.0_192, -0.1_678,
               0.0_709, -0.1_867, -0.0_655, -0.0_274, -0.0_234, -0.1_884, -0.0_516, -0.0_554,
               -0.0_274, -0.1_425, -0.1_423, 0.0_837, 0.0_377, -0.0_854
           ]					)
       # fmt: on

       __lowerCAmelCase					:						int					=					self._load_datasamples(1					)
       __lowerCAmelCase					:						Any					=					WhisperFeatureExtractor()
       __lowerCAmelCase					:						Optional[Any]					=					feature_extractor(A_      ,							return_tensors='''pt'''					).input_features
       self.assertEqual(input_features.shape      ,							(1, 80, 3000)					)
       self.assertTrue(torch.allclose(input_features[0, 0, :30]      ,							A_      ,							atol=1e-4					)					)





 def 	UpperCamelCase__  (							self					)					->Any:



       '''simple docstring'''





       __lowerCAmelCase					:						Tuple					=					self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()					)
       __lowerCAmelCase					:						str					=					self._load_datasamples(1					)[0]
       __lowerCAmelCase					:						Optional[Any]					=					((audio - audio.min()) / (audio.max() - audio.min())) * 6_5535  # Rescale to [0, 65535] to show issue
       __lowerCAmelCase					:						Union[str, Any]					=					feat_extract.zero_mean_unit_var_norm([audio]      ,							attention_mask=A_					)[0]

       self.assertTrue(np.all(np.mean(A_					) < 1e-3					)					)
       self.assertTrue(np.all(np.abs(np.var(A_					) - 1					) < 1e-3					)					)


