

'''simple docstring'''
import unittest

from transformers import PegasusTokenizer, PegasusTokenizerFast
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, require_torch, slow
from transformers.utils import cached_property

from ...test_tokenization_common import TokenizerTesterMixin


lowerCamelCase			:				Any 			=					get_tests_dir("fixtures/test_sentencepiece_no_bos.model")







@require_sentencepiece
@require_tokenizers
class 							A__   (	A__					,       unittest.TestCase  ):
  A__					=    PegasusTokenizer
  A__					=    PegasusTokenizerFast
  A__					=    True
  A__					=    True





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





       '''simple docstring'''






       super().setUp()

       # We have a SentencePiece fixture for testing
       _SCREAMING_SNAKE_CASE							   =PegasusTokenizer(_a			)
       tokenizer.save_pretrained(self.tmpdirname			)





  @cached_property
  def 						A  (		self				:     Union[str, Any]			)     ->   int:





       '''simple docstring'''






       return PegasusTokenizer.from_pretrained('google/pegasus-large'			)





  def 						A  (		self				:     Tuple							, **_a				:     Optional[Any]			)     ->   PegasusTokenizer:





       '''simple docstring'''






       return PegasusTokenizer.from_pretrained(self.tmpdirname							, **_a			)





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





       '''simple docstring'''






       return ("This is a test", "This is a test")





  def 						A  (		self				:     Dict			)     ->   Tuple:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   ='</s>'
       _SCREAMING_SNAKE_CASE							   =1

       self.assertEqual(self.get_tokenizer()._convert_token_to_id(_a			)							, _a			)
       self.assertEqual(self.get_tokenizer()._convert_id_to_token(_a			)							, _a			)





  def 						A  (		self				:     str			)     ->   str:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =list(self.get_tokenizer().get_vocab().keys()			)

       self.assertEqual(vocab_keys[0]							, '<pad>'			)
       self.assertEqual(vocab_keys[1]							, '</s>'			)
       self.assertEqual(vocab_keys[-1]							, 'v'			)
       self.assertEqual(len(_a			)							, 1103			)





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





       '''simple docstring'''






       self.assertEqual(self.get_tokenizer().vocab_size							, 1103			)





  def 						A  (		self				:     Optional[int]			)     ->   int:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =self.rust_tokenizer_class.from_pretrained(self.tmpdirname			)
       _SCREAMING_SNAKE_CASE							   =self.tokenizer_class.from_pretrained(self.tmpdirname			)
       _SCREAMING_SNAKE_CASE							   =(
           'Let\'s see which <unk> is the better <unk_token_11> one <mask_1> It seems like this <mask_2> was important'
           ' </s> <pad> <pad> <pad>'
       )
       _SCREAMING_SNAKE_CASE							   =rust_tokenizer([raw_input_str]							, return_tensors=_a							, add_special_tokens=_a			).input_ids[0]
       _SCREAMING_SNAKE_CASE							   =py_tokenizer([raw_input_str]							, return_tensors=_a							, add_special_tokens=_a			).input_ids[0]
       self.assertListEqual(_a							, _a			)





  def 						A  (		self				:     Any			)     ->   int:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =self._large_tokenizer
       # <mask_1> masks whole sentence while <mask_2> masks single word
       _SCREAMING_SNAKE_CASE							   ='<mask_1> To ensure a <mask_2> flow of bank resolutions.'
       _SCREAMING_SNAKE_CASE							   =[2, 413, 615, 114, 3, 1971, 113, 1679, 1_0710, 107, 1]
       _SCREAMING_SNAKE_CASE							   =tokenizer([raw_input_str]							, return_tensors=_a			).input_ids[0]
       self.assertListEqual(_a							, _a			)





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





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =self._large_tokenizer
       # The tracebacks for the following asserts are **better** without messages or self.assertEqual
       assert tokenizer.vocab_size == 9_6103
       assert tokenizer.pad_token_id == 0
       assert tokenizer.eos_token_id == 1
       assert tokenizer.offset == 103
       assert tokenizer.unk_token_id == tokenizer.offset + 2 == 105
       assert tokenizer.unk_token == "<unk>"
       assert tokenizer.model_max_length == 1024
       _SCREAMING_SNAKE_CASE							   ='To ensure a smooth flow of bank resolutions.'
       _SCREAMING_SNAKE_CASE							   =[413, 615, 114, 2291, 1971, 113, 1679, 1_0710, 107, 1]
       _SCREAMING_SNAKE_CASE							   =tokenizer([raw_input_str]							, return_tensors=_a			).input_ids[0]
       self.assertListEqual(_a							, _a			)
       assert tokenizer.convert_ids_to_tokens([0, 1, 2, 3]			) == ["<pad>", "</s>", "<mask_1>", "<mask_2>"]





  @require_torch
  def 						A  (		self				:     Tuple			)     ->   Any:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =['This is going to be way too long.' * 150, 'short example']
       _SCREAMING_SNAKE_CASE							   =['not super long but more than 5 tokens', 'tiny']
       _SCREAMING_SNAKE_CASE							   =self._large_tokenizer(_a							, padding=_a							, truncation=_a							, return_tensors='pt'			)
       _SCREAMING_SNAKE_CASE							   =self._large_tokenizer(
           text_target=_a							, max_length=5							, padding=_a							, truncation=_a							, return_tensors='pt'			)

       assert batch.input_ids.shape == (2, 1024)
       assert batch.attention_mask.shape == (2, 1024)
       assert targets["input_ids"].shape == (2, 5)
       assert len(_a			) == 2  # input_ids, attention_mask.





  @slow
  def 						A  (		self				:     Any			)     ->   List[str]:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   ={'input_ids': [[3_8979, 143, 1_8485, 606, 130, 2_6669, 8_7686, 121, 5_4189, 1129, 111, 2_6669, 8_7686, 121, 9114, 1_4787, 121, 1_3249, 158, 592, 956, 121, 1_4621, 3_1576, 143, 6_2613, 108, 9688, 930, 4_3430, 1_1562, 6_2613, 304, 108, 1_1443, 897, 108, 9314, 1_7415, 6_3399, 108, 1_1443, 7614, 1_8316, 118, 4284, 7148, 1_2430, 143, 1400, 2_5703, 158, 111, 4284, 7148, 1_1772, 143, 2_1297, 1064, 158, 122, 204, 3506, 1754, 1133, 1_4787, 1581, 115, 3_3224, 4482, 111, 1355, 110, 2_9173, 317, 5_0833, 108, 2_0147, 9_4665, 111, 7_7198, 107, 1], [110, 6_2613, 117, 638, 112, 1133, 121, 2_0098, 1355, 7_9050, 1_3872, 135, 1596, 5_3541, 1352, 141, 1_3039, 5542, 124, 302, 518, 111, 268, 2956, 115, 149, 4427, 107, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [139, 1235, 2799, 1_8289, 1_7780, 204, 109, 9474, 1296, 107, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], 'attention_mask': [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]}  # noqa: E501
       # fmt: on

       self.tokenizer_integration_test_util(
           expected_encoding=_a							, model_name='google/bigbird-pegasus-large-arxiv'							, revision='ba85d0851d708441f91440d509690f1ab6353415'							, )







@require_sentencepiece
@require_tokenizers
class 							A__   (	A__					,       unittest.TestCase  ):
  A__					=    PegasusTokenizer
  A__					=    PegasusTokenizerFast
  A__					=    True
  A__					=    True





  def 						A  (		self				:     str			)     ->   List[str]:





       '''simple docstring'''






       super().setUp()

       # We have a SentencePiece fixture for testing
       _SCREAMING_SNAKE_CASE							   =PegasusTokenizer(_a							, offset=0							, mask_token_sent=_a							, mask_token='[MASK]'			)
       tokenizer.save_pretrained(self.tmpdirname			)





  @cached_property
  def 						A  (		self				:     List[Any]			)     ->   Any:





       '''simple docstring'''






       return PegasusTokenizer.from_pretrained('google/bigbird-pegasus-large-arxiv'			)





  def 						A  (		self				:     Tuple							, **_a				:     Union[str, Any]			)     ->   PegasusTokenizer:





       '''simple docstring'''






       return PegasusTokenizer.from_pretrained(self.tmpdirname							, **_a			)





  def 						A  (		self				:     Any							, _a				:     Optional[int]			)     ->   str:





       '''simple docstring'''






       return ("This is a test", "This is a test")





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





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =self.rust_tokenizer_class.from_pretrained(self.tmpdirname			)
       _SCREAMING_SNAKE_CASE							   =self.tokenizer_class.from_pretrained(self.tmpdirname			)
       _SCREAMING_SNAKE_CASE							   =(
           'Let\'s see which <unk> is the better <unk_token> one [MASK] It seems like this [MASK] was important </s>'
           ' <pad> <pad> <pad>'
       )
       _SCREAMING_SNAKE_CASE							   =rust_tokenizer([raw_input_str]							, return_tensors=_a							, add_special_tokens=_a			).input_ids[0]
       _SCREAMING_SNAKE_CASE							   =py_tokenizer([raw_input_str]							, return_tensors=_a							, add_special_tokens=_a			).input_ids[0]
       self.assertListEqual(_a							, _a			)





  @require_torch
  def 						A  (		self				:     Tuple			)     ->   Union[str, Any]:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =['This is going to be way too long.' * 1000, 'short example']
       _SCREAMING_SNAKE_CASE							   =['not super long but more than 5 tokens', 'tiny']
       _SCREAMING_SNAKE_CASE							   =self._large_tokenizer(_a							, padding=_a							, truncation=_a							, return_tensors='pt'			)
       _SCREAMING_SNAKE_CASE							   =self._large_tokenizer(
           text_target=_a							, max_length=5							, padding=_a							, truncation=_a							, return_tensors='pt'			)

       assert batch.input_ids.shape == (2, 4096)
       assert batch.attention_mask.shape == (2, 4096)
       assert targets["input_ids"].shape == (2, 5)
       assert len(_a			) == 2  # input_ids, attention_mask.





  def 						A  (		self				:     Dict			)     ->   int:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =(
           'This is an example string that is used to test the original TF implementation against the HF'
           ' implementation'
       )

       _SCREAMING_SNAKE_CASE							   =self._large_tokenizer(_a			).input_ids

       self.assertListEqual(
           _a							, [182, 117, 142, 587, 4211, 120, 117, 263, 112, 804, 109, 856, 2_5016, 3137, 464, 109, 2_6955, 3137, 1]							, )



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

lowerCamelCase			:				List[str] 			=					random.Random()


def 	_lowerCAmelCase (						_UpperCamelCase						:					Optional[Any]							,			_UpperCamelCase						:					List[str]=1.0							,			_UpperCamelCase						:					Optional[int]=None							,			_UpperCamelCase						:					Dict=None    )				->      Any:
     """simple docstring"""




     if rng is None:
          _SCREAMING_SNAKE_CASE							   =global_rng

     _SCREAMING_SNAKE_CASE							   =[]
     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  ):





  def __init__(		self				:     List[Any]							, _a				:     Tuple							, _a				:     Dict=7							, _a				:     List[Any]=400							, _a				:     List[str]=2000							, _a				:     Optional[Any]=10							, _a				:     Dict=160							, _a				:     Tuple=8							, _a				:     Any=0.0							, _a				:     Optional[Any]=4000							, _a				:     List[Any]=False							, _a				:     Dict=True							, )     ->   Union[str, Any]:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =parent
       _SCREAMING_SNAKE_CASE							   =batch_size
       _SCREAMING_SNAKE_CASE							   =min_seq_length
       _SCREAMING_SNAKE_CASE							   =max_seq_length
       _SCREAMING_SNAKE_CASE							   =(self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
       _SCREAMING_SNAKE_CASE							   =padding_value
       _SCREAMING_SNAKE_CASE							   =sampling_rate
       _SCREAMING_SNAKE_CASE							   =return_attention_mask
       _SCREAMING_SNAKE_CASE							   =do_normalize
       _SCREAMING_SNAKE_CASE							   =feature_size
       _SCREAMING_SNAKE_CASE							   =chunk_length
       _SCREAMING_SNAKE_CASE							   =hop_length





  def 						A  (		self				:     Any			)     ->   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 						A  (		self				:     Optional[Any]							, _a				:     Any=False							, _a				:     Union[str, Any]=False			)     ->   Optional[Any]:





       '''simple docstring'''






       def _flatten(_a				:     Union[str, Any]			):
            return list(itertools.chain(*_a			)			)

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







@require_torch
@require_torchaudio
class 							A__   (	A__					,       unittest.TestCase  ):
  A__					=    WhisperFeatureExtractor if is_speech_available() else None





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





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =WhisperFeatureExtractionTester(self			)





  def 						A  (		self				:     str			)     ->   Tuple:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =self.feature_extraction_class(**self.feat_extract_dict			)

       with tempfile.TemporaryDirectory() as tmpdirname:
            _SCREAMING_SNAKE_CASE							   =feat_extract_first.save_pretrained(_a			)[0]
            check_json_file_has_correct_format(_a			)
            _SCREAMING_SNAKE_CASE							   =self.feature_extraction_class.from_pretrained(_a			)

       _SCREAMING_SNAKE_CASE							   =feat_extract_first.to_dict()
       _SCREAMING_SNAKE_CASE							   =feat_extract_second.to_dict()
       _SCREAMING_SNAKE_CASE							   =feat_extract_first.mel_filters
       _SCREAMING_SNAKE_CASE							   =feat_extract_second.mel_filters
       self.assertTrue(np.allclose(_a							, _a			)			)
       self.assertEqual(_a							, _a			)





  def 						A  (		self				:     Tuple			)     ->   Any:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =self.feature_extraction_class(**self.feat_extract_dict			)

       with tempfile.TemporaryDirectory() as tmpdirname:
            _SCREAMING_SNAKE_CASE							   =os.path.join(_a							, 'feat_extract.json'			)
            feat_extract_first.to_json_file(_a			)
            _SCREAMING_SNAKE_CASE							   =self.feature_extraction_class.from_json_file(_a			)

       _SCREAMING_SNAKE_CASE							   =feat_extract_first.to_dict()
       _SCREAMING_SNAKE_CASE							   =feat_extract_second.to_dict()
       _SCREAMING_SNAKE_CASE							   =feat_extract_first.mel_filters
       _SCREAMING_SNAKE_CASE							   =feat_extract_second.mel_filters
       self.assertTrue(np.allclose(_a							, _a			)			)
       self.assertEqual(_a							, _a			)





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





       '''simple docstring'''






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

       # Test feature size
       _SCREAMING_SNAKE_CASE							   =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
       _SCREAMING_SNAKE_CASE							   =feature_extractor(speech_inputs[0]							, return_tensors='np'			).input_features
       _SCREAMING_SNAKE_CASE							   =feature_extractor(np_speech_inputs[0]							, return_tensors='np'			).input_features
       self.assertTrue(np.allclose(_a							, _a							, atol=1e-3			)			)

       # Test batched
       _SCREAMING_SNAKE_CASE							   =feature_extractor(_a							, return_tensors='np'			).input_features
       _SCREAMING_SNAKE_CASE							   =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.
       _SCREAMING_SNAKE_CASE							   =[floats_list((1, x)			)[0] for x in (800, 800, 800)]
       _SCREAMING_SNAKE_CASE							   =np.asarray(_a			)
       _SCREAMING_SNAKE_CASE							   =feature_extractor(_a							, return_tensors='np'			).input_features
       _SCREAMING_SNAKE_CASE							   =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
       _SCREAMING_SNAKE_CASE							   =[floats_list((1, x)			)[0] for x in range(200							, (feature_extractor.n_samples + 500)							, 200			)]
       _SCREAMING_SNAKE_CASE							   =[np.asarray(_a			) for speech_input in speech_inputs]

       _SCREAMING_SNAKE_CASE							   =[x[: feature_extractor.n_samples] for x in speech_inputs]
       _SCREAMING_SNAKE_CASE							   =[np.asarray(_a			) for speech_input in speech_inputs_truncated]

       _SCREAMING_SNAKE_CASE							   =feature_extractor(_a							, return_tensors='np'			).input_features
       _SCREAMING_SNAKE_CASE							   =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 						A  (		self				:     Any			)     ->   List[Any]:





       '''simple docstring'''






       import torch

       _SCREAMING_SNAKE_CASE							   =self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()			)
       _SCREAMING_SNAKE_CASE							   =np.random.rand(100							, 32			).astype(np.floataa			)
       _SCREAMING_SNAKE_CASE							   =np_speech_inputs.tolist()

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





  def 						A  (		self				:     Tuple							, _a				:     str			)     ->   Optional[Any]:





       '''simple docstring'''






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

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





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





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =torch.tensor(
           [
               0.11_93, -0.09_46, -0.10_98, -0.01_96, 0.02_25, -0.06_90, -0.17_36, 0.09_51,
               0.09_71, -0.08_17, -0.07_02, 0.01_62, 0.02_60, 0.00_17, -0.01_92, -0.16_78,
               0.07_09, -0.18_67, -0.06_55, -0.02_74, -0.02_34, -0.18_84, -0.05_16, -0.05_54,
               -0.02_74, -0.14_25, -0.14_23, 0.08_37, 0.03_77, -0.08_54
           ]			)
       # fmt: on

       _SCREAMING_SNAKE_CASE							   =self._load_datasamples(1			)
       _SCREAMING_SNAKE_CASE							   =WhisperFeatureExtractor()
       _SCREAMING_SNAKE_CASE							   =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 						A  (		self				:     Union[str, Any]			)     ->   Tuple:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()			)
       _SCREAMING_SNAKE_CASE							   =self._load_datasamples(1			)[0]
       _SCREAMING_SNAKE_CASE							   =((audio - audio.min()) / (audio.max() - audio.min())) * 6_5535  # Rescale to [0, 65535] to show issue
       _SCREAMING_SNAKE_CASE							   =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			)			)
