
'''simple docstring'''







import unittest

from transformers import BarthezTokenizer, BarthezTokenizerFast, BatchEncoding
from transformers.testing_utils import require_sentencepiece, require_tokenizers, require_torch, slow

from ...test_tokenization_common import TokenizerTesterMixin







@require_tokenizers
@require_sentencepiece
@slow  # see https://github.com/huggingface/transformers/issues/11457
class UpperCAmelCase__	( lowercase__    ,				unittest.TestCase	):





  """simple docstring"""

  __UpperCAmelCase				:				List[str]   =					BarthezTokenizer
  __UpperCAmelCase				:				Optional[Any]   =					BarthezTokenizerFast
  __UpperCAmelCase				:				List[str]   =					True
  __UpperCAmelCase				:				str   =					True


  def   __lowercase		(		self      :     Tuple       ):


     '''simple docstring'''






     super().setUp()

     _a				:	str			=   BarthezTokenizerFast.from_pretrained('moussaKam/mbarthez'       )
     tokenizer.save_pretrained(self.tmpdirname       )
     tokenizer.save_pretrained(self.tmpdirname							,legacy_format=_a       )
     _a				:	List[str]			=   tokenizer


  def   __lowercase		(		self      :     List[Any]       ):


     '''simple docstring'''






     _a				:	str			=   '<pad>'
     _a				:	str			=   1

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


  def   __lowercase		(		self      :     List[str]       ):


     '''simple docstring'''






     _a				:	Any			=   list(self.get_tokenizer().get_vocab().keys()       )

     self.assertEqual(vocab_keys[0]							,'<s>'       )
     self.assertEqual(vocab_keys[1]							,'<pad>'       )
     self.assertEqual(vocab_keys[-1]							,'<mask>'       )
     self.assertEqual(len(_a       )							,10_1122       )


  def   __lowercase		(		self      :     List[Any]       ):


     '''simple docstring'''






     self.assertEqual(self.get_tokenizer().vocab_size							,10_1122       )


  @require_torch
  def   __lowercase		(		self      :     Optional[int]       ):


     '''simple docstring'''






     _a				:	Any			=   ['A long paragraph for summarization.', 'Another paragraph for summarization.']
     _a				:	Optional[Any]			=   [0, 57, 3018, 7_0307, 91, 2]

     _a				:	Optional[int]			=   self.tokenizer(
         _a							,max_length=len(_a       )							,padding=_a							,truncation=_a							,return_tensors='pt'       )
     self.assertIsInstance(_a							,_a       )

     self.assertEqual((2, 6)							,batch.input_ids.shape       )
     self.assertEqual((2, 6)							,batch.attention_mask.shape       )
     _a				:	List[Any]			=   batch.input_ids.tolist()[0]
     self.assertListEqual(_a							,_a       )


  def   __lowercase		(		self      :     Optional[Any]       ):


     '''simple docstring'''






     if not self.test_rust_tokenizer:
        return

     _a				:	Dict			=   self.get_tokenizer()
     _a				:	Optional[Any]			=   self.get_rust_tokenizer()

     _a				:	Union[str, Any]			=   'I was born in 92000, and this is falsé.'

     _a				:	int			=   tokenizer.tokenize(_a       )
     _a				:	Optional[Any]			=   rust_tokenizer.tokenize(_a       )
     self.assertListEqual(_a							,_a       )

     _a				:	List[str]			=   tokenizer.encode(_a							,add_special_tokens=_a       )
     _a				:	List[Any]			=   rust_tokenizer.encode(_a							,add_special_tokens=_a       )
     self.assertListEqual(_a							,_a       )

     _a				:	Optional[int]			=   self.get_rust_tokenizer()
     _a				:	List[str]			=   tokenizer.encode(_a       )
     _a				:	int			=   rust_tokenizer.encode(_a       )
     self.assertListEqual(_a							,_a       )


  @slow
  def   __lowercase		(		self      :     List[Any]       ):


     '''simple docstring'''






     _a				:	List[Any]			=   {'input_ids': [[0, 490, 1_4328, 4507, 354, 47, 4_3669, 95, 25, 7_8117, 2_0215, 1_9779, 190, 22, 400, 4, 3_5343, 8_0310, 603, 86, 2_4937, 105, 3_3438, 9_4762, 196, 3_9642, 7, 15, 1_5933, 173, 2, 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, 1_0534, 87, 25, 66, 3358, 196, 5_5289, 8, 8_2961, 81, 2204, 7_5203, 7, 15, 763, 1_2956, 216, 178, 1_4328, 9595, 1377, 6_9693, 7, 448, 7_1021, 196, 1_8106, 1437, 1_3974, 108, 9083, 4, 4_9315, 7, 39, 86, 1326, 2793, 4_6333, 4, 448, 196, 7_4588, 7, 4_9315, 7, 39, 21, 822, 3_8470, 74, 21, 6_6723, 6_2480, 8, 2_2050, 5, 2]], '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, 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, 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]]}  # noqa: E501
     # fmt: on

     # moussaKam/mbarthez is a french model. So we also use french texts.
     _a				:	Tuple			=   [
         'Le transformeur est un modèle d\'apprentissage profond introduit en 2017, '
         'utilisé principalement dans le domaine du traitement automatique des langues (TAL).',
         'À l\'instar des réseaux de neurones récurrents (RNN), les transformeurs sont conçus '
         'pour gérer des données séquentielles, telles que le langage naturel, pour des tâches '
         'telles que la traduction et la synthèse de texte.',
     ]

     self.tokenizer_integration_test_util(
         expected_encoding=_a							,model_name='moussaKam/mbarthez'							,revision='c2e4ecbca5e3cd2c37fe1ac285ca4fbdf1366fb6'							,sequences=_a							,)





'''simple docstring'''







import numpy as np

from transformers import BatchFeature
from transformers.testing_utils import require_tf, require_torch

from .test_feature_extraction_common import FeatureExtractionSavingTestMixin







class UpperCAmelCase__	( lowercase__	):





  """simple docstring"""

  __UpperCAmelCase				:				Union[str, Any]   =					None
  __UpperCAmelCase				:				List[Any]   =					None


  @property
  def   __lowercase		(		self      :     Dict       ):


     '''simple docstring'''






     return self.feat_extract_tester.prepare_feat_extract_dict()


  def   __lowercase		(		self      :     str       ):


     '''simple docstring'''






     _a				:	Dict			=   self.feature_extraction_class(**self.feat_extract_dict       )
     self.assertTrue(hasattr(_a							,'feature_size'       )       )
     self.assertTrue(hasattr(_a							,'sampling_rate'       )       )
     self.assertTrue(hasattr(_a							,'padding_value'       )       )


  def   __lowercase		(		self      :     int       ):


     '''simple docstring'''






     _a				:	Any			=   self.feat_extract_tester.prepare_inputs_for_common()
     _a				:	str			=   self.feature_extraction_class(**self.feat_extract_dict       )
     _a				:	int			=   feat_extract.model_input_names[0]

     _a				:	List[Any]			=   BatchFeature({input_name: speech_inputs}       )

     self.assertTrue(all(len(_a       ) == len(_a       ) for x, y in zip(_a							,processed_features[input_name]       )       )       )

     _a				:	Any			=   self.feat_extract_tester.prepare_inputs_for_common(equal_length=_a       )
     _a				:	Union[str, Any]			=   BatchFeature({input_name: speech_inputs}							,tensor_type='np'       )

     _a				:	Union[str, Any]			=   processed_features[input_name]

     if len(batch_features_input.shape       ) < 3:
        _a				:	Optional[int]			=   batch_features_input[:, :, None]

     self.assertTrue(
         batch_features_input.shape
         == (self.feat_extract_tester.batch_size, len(speech_inputs[0]       ), self.feat_extract_tester.feature_size)       )


  @require_torch
  def   __lowercase		(		self      :     Any       ):


     '''simple docstring'''






     _a				:	List[Any]			=   self.feat_extract_tester.prepare_inputs_for_common(equal_length=_a       )
     _a				:	Dict			=   self.feature_extraction_class(**self.feat_extract_dict       )
     _a				:	int			=   feat_extract.model_input_names[0]

     _a				:	str			=   BatchFeature({input_name: speech_inputs}							,tensor_type='pt'       )

     _a				:	str			=   processed_features[input_name]

     if len(batch_features_input.shape       ) < 3:
        _a				:	str			=   batch_features_input[:, :, None]

     self.assertTrue(
         batch_features_input.shape
         == (self.feat_extract_tester.batch_size, len(speech_inputs[0]       ), self.feat_extract_tester.feature_size)       )


  @require_tf
  def   __lowercase		(		self      :     int       ):


     '''simple docstring'''






     _a				:	int			=   self.feat_extract_tester.prepare_inputs_for_common(equal_length=_a       )
     _a				:	Dict			=   self.feature_extraction_class(**self.feat_extract_dict       )
     _a				:	Tuple			=   feat_extract.model_input_names[0]

     _a				:	int			=   BatchFeature({input_name: speech_inputs}							,tensor_type='tf'       )

     _a				:	Optional[int]			=   processed_features[input_name]

     if len(batch_features_input.shape       ) < 3:
        _a				:	Optional[Any]			=   batch_features_input[:, :, None]

     self.assertTrue(
         batch_features_input.shape
         == (self.feat_extract_tester.batch_size, len(speech_inputs[0]       ), self.feat_extract_tester.feature_size)       )


  def   __lowercase		(		self      :     Dict							,_a      :     Any=False       ):


     '''simple docstring'''






     def _inputs_have_equal_length(_a      :     Tuple       ):
        _a				:	Tuple			=   len(input[0]       )
        for input_slice in input[1:]:
           if len(_a       ) != length:
              return False
        return True

     def _inputs_are_equal(_a      :     Optional[Any]							,_a      :     Union[str, Any]       ):
        if len(_a       ) != len(_a       ):
           return False

        for input_slice_a, input_slice_a in zip(_a							,_a       ):
           if not np.allclose(np.asarray(_a       )							,np.asarray(_a       )							,atol=1E-3       ):
              return False
        return True

     _a				:	int			=   self.feature_extraction_class(**self.feat_extract_dict       )
     _a				:	Tuple			=   self.feat_extract_tester.prepare_inputs_for_common(numpify=_a       )
     _a				:	Union[str, Any]			=   feat_extract.model_input_names[0]

     _a				:	Tuple			=   BatchFeature({input_name: speech_inputs}       )

     _a				:	str			=   self.feat_extract_tester.seq_length_diff
     _a				:	Dict			=   self.feat_extract_tester.max_seq_length + pad_diff
     _a				:	Dict			=   self.feat_extract_tester.min_seq_length
     _a				:	Optional[Any]			=   self.feat_extract_tester.batch_size
     _a				:	Tuple			=   self.feat_extract_tester.feature_size

     # test padding for List[int] + numpy
     _a				:	int			=   feat_extract.pad(_a							,padding=_a       )
     _a				:	List[Any]			=   input_a[input_name]

     _a				:	Tuple			=   feat_extract.pad(_a							,padding='longest'       )
     _a				:	Any			=   input_a[input_name]

     _a				:	Optional[Any]			=   feat_extract.pad(_a							,padding='max_length'							,max_length=len(speech_inputs[-1]       )       )
     _a				:	List[str]			=   input_a[input_name]

     _a				:	List[str]			=   feat_extract.pad(_a							,padding='longest'							,return_tensors='np'       )
     _a				:	str			=   input_a[input_name]

     # max_length parameter has to be provided when setting `padding="max_length"`
     with self.assertRaises(_a       ):
        feat_extract.pad(_a							,padding='max_length'       )[input_name]

     _a				:	int			=   feat_extract.pad(
         _a							,padding='max_length'							,max_length=_a							,return_tensors='np'       )
     _a				:	Optional[int]			=   input_a[input_name]

     self.assertFalse(_inputs_have_equal_length(_a       )       )
     self.assertTrue(_inputs_have_equal_length(_a       )       )
     self.assertTrue(_inputs_have_equal_length(_a       )       )
     self.assertTrue(_inputs_are_equal(_a							,_a       )       )
     self.assertTrue(len(input_a[0]       ) == pad_min_length       )
     self.assertTrue(len(input_a[1]       ) == pad_min_length + pad_diff       )
     self.assertTrue(input_a.shape[:2] == (batch_size, len(input_a[0]       ))       )
     self.assertTrue(input_a.shape[:2] == (batch_size, pad_max_length)       )

     if feature_size > 1:
        self.assertTrue(input_a.shape[2] == input_a.shape[2] == feature_size       )

     # test padding for `pad_to_multiple_of` for List[int] + numpy
     _a				:	Tuple			=   feat_extract.pad(_a							,pad_to_multiple_of=10       )
     _a				:	List[str]			=   input_a[input_name]

     _a				:	str			=   feat_extract.pad(_a							,padding='longest'							,pad_to_multiple_of=10       )
     _a				:	Tuple			=   input_a[input_name]

     _a				:	Optional[int]			=   feat_extract.pad(
         _a							,padding='max_length'							,pad_to_multiple_of=10							,max_length=_a       )
     _a				:	Any			=   input_a[input_name]

     _a				:	Optional[int]			=   feat_extract.pad(
         _a							,padding='max_length'							,pad_to_multiple_of=10							,max_length=_a							,return_tensors='np'							,)
     _a				:	Dict			=   input_a[input_name]

     self.assertTrue(all(len(_a       ) % 10 == 0 for x in input_a       )       )
     self.assertTrue(_inputs_are_equal(_a							,_a       )       )

     _a				:	List[str]			=   pad_max_length if pad_max_length % 10 == 0 else (pad_max_length // 10 + 1) * 10
     self.assertTrue(all(len(_a       ) == expected_mult_pad_length for x in input_a       )       )
     self.assertEqual(input_a.shape[:2]							,(batch_size, expected_mult_pad_length)       )

     if feature_size > 1:
        self.assertTrue(input_a.shape[2] == feature_size       )

     # Check padding value is correct
     _a				:	Any			=   (np.ones(self.feat_extract_tester.feature_size       ) * feat_extract.padding_value).sum()
     self.assertTrue(
         abs(np.asarray(input_a[0]       )[pad_min_length:].sum() - padding_vector_sum * (pad_max_length - pad_min_length)       )
         < 1E-3       )
     self.assertTrue(
         abs(
             np.asarray(input_a[1]       )[pad_min_length + pad_diff :].sum()
             - padding_vector_sum * (pad_max_length - pad_min_length - pad_diff)       )
         < 1E-3       )
     self.assertTrue(
         abs(
             np.asarray(input_a[2]       )[pad_min_length + 2 * pad_diff :].sum()
             - padding_vector_sum * (pad_max_length - pad_min_length - 2 * pad_diff)       )
         < 1E-3       )
     self.assertTrue(
         abs(input_a[0, pad_min_length:].sum() - padding_vector_sum * (pad_max_length - pad_min_length)       ) < 1E-3       )
     self.assertTrue(
         abs(input_a[0, pad_min_length:].sum() - padding_vector_sum * (expected_mult_pad_length - pad_min_length)       )
         < 1E-3       )


  def   __lowercase		(		self      :     List[Any]							,_a      :     Optional[int]=False       ):


     '''simple docstring'''






     def _inputs_have_equal_length(_a      :     List[str]       ):
        _a				:	Union[str, Any]			=   len(input[0]       )
        for input_slice in input[1:]:
           if len(_a       ) != length:
              return False
        return True

     def _inputs_are_equal(_a      :     List[str]							,_a      :     List[str]       ):
        if len(_a       ) != len(_a       ):
           return False

        for input_slice_a, input_slice_a in zip(_a							,_a       ):
           if not np.allclose(np.asarray(_a       )							,np.asarray(_a       )							,atol=1E-3       ):
              return False
        return True

     _a				:	Dict			=   self.feature_extraction_class(**self.feat_extract_dict       )
     _a				:	str			=   self.feat_extract_tester.prepare_inputs_for_common(numpify=_a       )
     _a				:	Any			=   feat_extract.model_input_names[0]

     _a				:	List[Any]			=   BatchFeature({input_name: speech_inputs}       )

     # truncate to smallest
     _a				:	Union[str, Any]			=   feat_extract.pad(
         _a							,padding='max_length'							,max_length=len(speech_inputs[0]       )							,truncation=_a       )
     _a				:	str			=   input_a[input_name]

     _a				:	List[str]			=   feat_extract.pad(_a							,padding='max_length'							,max_length=len(speech_inputs[0]       )       )
     _a				:	Tuple			=   input_a[input_name]

     self.assertTrue(_inputs_have_equal_length(_a       )       )
     self.assertFalse(_inputs_have_equal_length(_a       )       )

     # truncate to smallest with np
     _a				:	Dict			=   feat_extract.pad(
         _a							,padding='max_length'							,max_length=len(speech_inputs[0]       )							,return_tensors='np'							,truncation=_a							,)
     _a				:	Any			=   input_a[input_name]

     _a				:	List[Any]			=   feat_extract.pad(
         _a							,padding='max_length'							,max_length=len(speech_inputs[0]       )							,return_tensors='np'       )
     _a				:	int			=   input_a[input_name]

     self.assertTrue(_inputs_have_equal_length(_a       )       )
     self.assertTrue(input_a.shape[1] == len(speech_inputs[0]       )       )

     # since truncation forces padding to be smaller than longest input
     # function can't return `np.ndarray`, but has to return list
     self.assertFalse(_inputs_have_equal_length(_a       )       )

     # truncate to middle
     _a				:	Dict			=   feat_extract.pad(
         _a							,padding='max_length'							,max_length=len(speech_inputs[1]       )							,truncation=_a							,return_tensors='np'							,)
     _a				:	List[Any]			=   input_a[input_name]

     _a				:	Tuple			=   feat_extract.pad(
         _a							,padding='max_length'							,max_length=len(speech_inputs[1]       )							,truncation=_a       )
     _a				:	Tuple			=   input_a[input_name]

     _a				:	Tuple			=   feat_extract.pad(
         _a							,padding='max_length'							,max_length=len(speech_inputs[1]       )							,return_tensors='np'       )
     _a				:	Dict			=   input_a[input_name]

     self.assertTrue(input_a.shape[1] == len(speech_inputs[1]       )       )
     self.assertTrue(_inputs_have_equal_length(_a       )       )
     self.assertTrue(_inputs_have_equal_length(_a       )       )
     self.assertTrue(_inputs_are_equal(_a							,_a       )       )

     # since truncation forces padding to be smaller than longest input
     # function can't return `np.ndarray`, but has to return list
     self.assertFalse(_inputs_have_equal_length(_a       )       )
     self.assertTrue(len(input_a[-1]       ) == len(speech_inputs[-1]       )       )

     # padding has to be max_length when setting `truncation=True`
     with self.assertRaises(_a       ):
        feat_extract.pad(_a							,truncation=_a       )[input_name]

     # padding has to be max_length when setting `truncation=True`
     with self.assertRaises(_a       ):
        feat_extract.pad(_a							,padding='longest'							,truncation=_a       )[input_name]

     # padding has to be max_length when setting `truncation=True`
     with self.assertRaises(_a       ):
        feat_extract.pad(_a							,padding='longest'							,truncation=_a       )[input_name]

     # max_length parameter has to be provided when setting `truncation=True` and padding="max_length"
     with self.assertRaises(_a       ):
        feat_extract.pad(_a							,padding='max_length'							,truncation=_a       )[input_name]

     # test truncation for `pad_to_multiple_of` for List[int] + numpy
     _a				:	Optional[Any]			=   12
     _a				:	List[Any]			=   feat_extract.pad(
         _a							,padding='max_length'							,max_length=len(speech_inputs[0]       )							,pad_to_multiple_of=_a							,truncation=_a							,)
     _a				:	Tuple			=   input_a[input_name]

     _a				:	str			=   feat_extract.pad(
         _a							,padding='max_length'							,max_length=len(speech_inputs[0]       )							,pad_to_multiple_of=_a							,)
     _a				:	List[Any]			=   input_a[input_name]

     # retrieve expected_length as multiple of pad_to_multiple_of
     _a				:	List[Any]			=   len(speech_inputs[0]       )
     if expected_length % pad_to_multiple_of != 0:
        _a				:	Union[str, Any]			=   ((len(speech_inputs[0]       ) // pad_to_multiple_of) + 1) * pad_to_multiple_of

     self.assertTrue(len(input_a[0]       ) == expected_length       )
     self.assertTrue(_inputs_have_equal_length(_a       )       )
     self.assertFalse(_inputs_have_equal_length(_a       )       )


  def   __lowercase		(		self      :     Union[str, Any]       ):


     '''simple docstring'''






     self._check_padding(numpify=_a       )


  def   __lowercase		(		self      :     Tuple       ):


     '''simple docstring'''






     self._check_padding(numpify=_a       )


  def   __lowercase		(		self      :     Dict       ):


     '''simple docstring'''






     self._check_truncation(numpify=_a       )


  def   __lowercase		(		self      :     str       ):


     '''simple docstring'''






     self._check_truncation(numpify=_a       )


  @require_torch
  def   __lowercase		(		self      :     Dict       ):


     '''simple docstring'''






     _a				:	Any			=   self.feature_extraction_class(**self.feat_extract_dict       )
     _a				:	List[Any]			=   self.feat_extract_tester.prepare_inputs_for_common()
     _a				:	Union[str, Any]			=   feat_extract.model_input_names[0]

     _a				:	Optional[int]			=   BatchFeature({input_name: speech_inputs}       )

     _a				:	List[Any]			=   feat_extract.pad(_a							,padding='longest'							,return_tensors='np'       )[input_name]
     _a				:	List[str]			=   feat_extract.pad(_a							,padding='longest'							,return_tensors='pt'       )[input_name]

     self.assertTrue(abs(input_np.astype(np.floataa       ).sum() - input_pt.numpy().astype(np.floataa       ).sum()       ) < 1E-2       )


  @require_tf
  def   __lowercase		(		self      :     int       ):


     '''simple docstring'''






     _a				:	List[str]			=   self.feature_extraction_class(**self.feat_extract_dict       )
     _a				:	Optional[Any]			=   self.feat_extract_tester.prepare_inputs_for_common()
     _a				:	Dict			=   feat_extract.model_input_names[0]

     _a				:	Optional[Any]			=   BatchFeature({input_name: speech_inputs}       )

     _a				:	Dict			=   feat_extract.pad(_a							,padding='longest'							,return_tensors='np'       )[input_name]
     _a				:	Any			=   feat_extract.pad(_a							,padding='longest'							,return_tensors='tf'       )[input_name]

     self.assertTrue(abs(input_np.astype(np.floataa       ).sum() - input_tf.numpy().astype(np.floataa       ).sum()       ) < 1E-2       )


  def   __lowercase		(		self      :     Union[str, Any]       ):


     '''simple docstring'''






     _a				:	str			=   self.feat_extract_dict
     _a				:	List[Any]			=   True
     _a				:	Optional[int]			=   self.feature_extraction_class(**_a       )
     _a				:	List[Any]			=   self.feat_extract_tester.prepare_inputs_for_common()
     _a				:	Tuple			=   [len(_a       ) for x in speech_inputs]
     _a				:	int			=   feat_extract.model_input_names[0]

     _a				:	Optional[Any]			=   BatchFeature({input_name: speech_inputs}       )

     _a				:	str			=   feat_extract.pad(_a							,padding='longest'							,return_tensors='np'       )
     self.assertIn('attention_mask'							,_a       )
     self.assertListEqual(list(processed.attention_mask.shape       )							,list(processed[input_name].shape[:2]       )       )
     self.assertListEqual(processed.attention_mask.sum(-1       ).tolist()							,_a       )


  def   __lowercase		(		self      :     int       ):


     '''simple docstring'''






     _a				:	Any			=   self.feat_extract_dict
     _a				:	Tuple			=   True
     _a				:	Optional[int]			=   self.feature_extraction_class(**_a       )
     _a				:	Dict			=   self.feat_extract_tester.prepare_inputs_for_common()
     _a				:	Dict			=   [len(_a       ) for x in speech_inputs]
     _a				:	Union[str, Any]			=   feat_extract.model_input_names[0]

     _a				:	Any			=   BatchFeature({input_name: speech_inputs}       )
     _a				:	List[Any]			=   min(_a       )

     _a				:	Dict			=   feat_extract.pad(
         _a							,padding='max_length'							,max_length=_a							,truncation=_a							,return_tensors='np'       )
     self.assertIn('attention_mask'							,_a       )
     self.assertListEqual(
         list(processed_pad.attention_mask.shape       )							,[processed_pad[input_name].shape[0], max_length]       )
     self.assertListEqual(
         processed_pad.attention_mask[:, :max_length].sum(-1       ).tolist()							,[max_length for x in speech_inputs]       )



