





"""simple docstring"""


from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


_A													=      {
    """configuration_funnel""": ["""FUNNEL_PRETRAINED_CONFIG_ARCHIVE_MAP""", """FunnelConfig"""],
    """convert_funnel_original_tf_checkpoint_to_pytorch""": [],
    """tokenization_funnel""": ["""FunnelTokenizer"""],
}

try:
  if not is_tokenizers_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  _A													=      ["""FunnelTokenizerFast"""]

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  _A													=      [
      """FUNNEL_PRETRAINED_MODEL_ARCHIVE_LIST""",
      """FunnelBaseModel""",
      """FunnelForMaskedLM""",
      """FunnelForMultipleChoice""",
      """FunnelForPreTraining""",
      """FunnelForQuestionAnswering""",
      """FunnelForSequenceClassification""",
      """FunnelForTokenClassification""",
      """FunnelModel""",
      """FunnelPreTrainedModel""",
      """load_tf_weights_in_funnel""",
  ]

try:
  if not is_tf_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  _A													=      [
      """TF_FUNNEL_PRETRAINED_MODEL_ARCHIVE_LIST""",
      """TFFunnelBaseModel""",
      """TFFunnelForMaskedLM""",
      """TFFunnelForMultipleChoice""",
      """TFFunnelForPreTraining""",
      """TFFunnelForQuestionAnswering""",
      """TFFunnelForSequenceClassification""",
      """TFFunnelForTokenClassification""",
      """TFFunnelModel""",
      """TFFunnelPreTrainedModel""",
  ]


if TYPE_CHECKING:
  from .configuration_funnel import FUNNEL_PRETRAINED_CONFIG_ARCHIVE_MAP, FunnelConfig
  from .tokenization_funnel import FunnelTokenizer

  try:
    if not is_tokenizers_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .tokenization_funnel_fast import FunnelTokenizerFast

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_funnel import (
        FUNNEL_PRETRAINED_MODEL_ARCHIVE_LIST,
        FunnelBaseModel,
        FunnelForMaskedLM,
        FunnelForMultipleChoice,
        FunnelForPreTraining,
        FunnelForQuestionAnswering,
        FunnelForSequenceClassification,
        FunnelForTokenClassification,
        FunnelModel,
        FunnelPreTrainedModel,
        load_tf_weights_in_funnel,
    )

  try:
    if not is_tf_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_tf_funnel import (
        TF_FUNNEL_PRETRAINED_MODEL_ARCHIVE_LIST,
        TFFunnelBaseModel,
        TFFunnelForMaskedLM,
        TFFunnelForMultipleChoice,
        TFFunnelForPreTraining,
        TFFunnelForQuestionAnswering,
        TFFunnelForSequenceClassification,
        TFFunnelForTokenClassification,
        TFFunnelModel,
        TFFunnelPreTrainedModel,
    )

else:
  import sys

  _A													=      _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)











"""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 _lowerCamelCase    (					a_						):
   # to overwrite at feature extractactor specific tests
   _lowerCamelCase    :Optional[int]     				=     None
   _lowerCamelCase    :List[Any]     				=     None






   @property
   def 	_lowerCAmelCase   (		self       :		int   )			->						Tuple:

         """simple docstring"""
         return self.feat_extract_tester.prepare_feat_extract_dict()






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

         """simple docstring"""
         lowerCAmelCase__      :			Union[str, Any]   =	self.feature_extraction_class(**self.feat_extract_dict   )
         self.assertTrue(hasattr(UpperCamelCase   ,     """feature_size"""   )   )
         self.assertTrue(hasattr(UpperCamelCase   ,     """sampling_rate"""   )   )
         self.assertTrue(hasattr(UpperCamelCase   ,     """padding_value"""   )   )






   def 	_lowerCAmelCase   (		self       :		Any   )			->						int:

         """simple docstring"""
         lowerCAmelCase__      :			Dict   =	self.feat_extract_tester.prepare_inputs_for_common()
         lowerCAmelCase__      :			List[Any]   =	self.feature_extraction_class(**self.feat_extract_dict   )
         lowerCAmelCase__      :			Union[str, Any]   =	feat_extract.model_input_names[0]

         lowerCAmelCase__      :			Any   =	BatchFeature({input_name: speech_inputs}   )

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

         lowerCAmelCase__      :			List[str]   =	self.feat_extract_tester.prepare_inputs_for_common(equal_length=UpperCamelCase   )
         lowerCAmelCase__      :			List[Any]   =	BatchFeature({input_name: speech_inputs}   ,     tensor_type="""np"""   )

         lowerCAmelCase__      :			Dict   =	processed_features[input_name]

         if len(batch_features_input.shape   ) < 3:
               lowerCAmelCase__      :			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 	_lowerCAmelCase   (		self       :		Tuple   )			->						Optional[Any]:

         """simple docstring"""
         lowerCAmelCase__      :			int   =	self.feat_extract_tester.prepare_inputs_for_common(equal_length=UpperCamelCase   )
         lowerCAmelCase__      :			str   =	self.feature_extraction_class(**self.feat_extract_dict   )
         lowerCAmelCase__      :			Optional[int]   =	feat_extract.model_input_names[0]

         lowerCAmelCase__      :			Union[str, Any]   =	BatchFeature({input_name: speech_inputs}   ,     tensor_type="""pt"""   )

         lowerCAmelCase__      :			str   =	processed_features[input_name]

         if len(batch_features_input.shape   ) < 3:
               lowerCAmelCase__      :			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_tf
   def 	_lowerCAmelCase   (		self       :		Optional[Any]   )			->						int:

         """simple docstring"""
         lowerCAmelCase__      :			List[str]   =	self.feat_extract_tester.prepare_inputs_for_common(equal_length=UpperCamelCase   )
         lowerCAmelCase__      :			str   =	self.feature_extraction_class(**self.feat_extract_dict   )
         lowerCAmelCase__      :			Dict   =	feat_extract.model_input_names[0]

         lowerCAmelCase__      :			Tuple   =	BatchFeature({input_name: speech_inputs}   ,     tensor_type="""tf"""   )

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

         if len(batch_features_input.shape   ) < 3:
               lowerCAmelCase__      :			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 	_lowerCAmelCase   (		self       :		List[Any]   ,     UpperCamelCase       :		Union[str, Any]=False   )			->						int:

         """simple docstring"""
         def _inputs_have_equal_length(UpperCamelCase       :		int   ):
               lowerCAmelCase__      :			Optional[Any]   =	len(input[0]   )
               for input_slice in input[1:]:
                     if len(UpperCamelCase   ) != length:
                           return False
               return True

         def _inputs_are_equal(UpperCamelCase       :		int   ,     UpperCamelCase       :		Dict   ):
               if len(UpperCamelCase   ) != len(UpperCamelCase   ):
                     return False

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

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

         lowerCAmelCase__      :			str   =	BatchFeature({input_name: speech_inputs}   )

         lowerCAmelCase__      :			Any   =	self.feat_extract_tester.seq_length_diff
         lowerCAmelCase__      :			List[str]   =	self.feat_extract_tester.max_seq_length + pad_diff
         lowerCAmelCase__      :			Optional[int]   =	self.feat_extract_tester.min_seq_length
         lowerCAmelCase__      :			Optional[int]   =	self.feat_extract_tester.batch_size
         lowerCAmelCase__      :			str   =	self.feat_extract_tester.feature_size

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

         lowerCAmelCase__      :			Tuple   =	feat_extract.pad(UpperCamelCase   ,     padding="""longest"""   )
         lowerCAmelCase__      :			Any   =	input_a[input_name]

         lowerCAmelCase__      :			List[str]   =	feat_extract.pad(UpperCamelCase   ,     padding="""max_length"""   ,     max_length=len(speech_inputs[-1]   )   )
         lowerCAmelCase__      :			Dict   =	input_a[input_name]

         lowerCAmelCase__      :			str   =	feat_extract.pad(UpperCamelCase   ,     padding="""longest"""   ,     return_tensors="""np"""   )
         lowerCAmelCase__      :			Optional[Any]   =	input_a[input_name]

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

         lowerCAmelCase__      :			Optional[int]   =	feat_extract.pad(
             UpperCamelCase   ,     padding="""max_length"""   ,     max_length=UpperCamelCase   ,     return_tensors="""np"""   )
         lowerCAmelCase__      :			int   =	input_a[input_name]

         self.assertFalse(_inputs_have_equal_length(UpperCamelCase   )   )
         self.assertTrue(_inputs_have_equal_length(UpperCamelCase   )   )
         self.assertTrue(_inputs_have_equal_length(UpperCamelCase   )   )
         self.assertTrue(_inputs_are_equal(UpperCamelCase   ,     UpperCamelCase   )   )
         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
         lowerCAmelCase__      :			Any   =	feat_extract.pad(UpperCamelCase   ,     pad_to_multiple_of=10   )
         lowerCAmelCase__      :			int   =	input_a[input_name]

         lowerCAmelCase__      :			Dict   =	feat_extract.pad(UpperCamelCase   ,     padding="""longest"""   ,     pad_to_multiple_of=10   )
         lowerCAmelCase__      :			Union[str, Any]   =	input_a[input_name]

         lowerCAmelCase__      :			Optional[int]   =	feat_extract.pad(
             UpperCamelCase   ,     padding="""max_length"""   ,     pad_to_multiple_of=10   ,     max_length=UpperCamelCase   )
         lowerCAmelCase__      :			str   =	input_a[input_name]

         lowerCAmelCase__      :			Union[str, Any]   =	feat_extract.pad(
             UpperCamelCase   ,     padding="""max_length"""   ,     pad_to_multiple_of=10   ,     max_length=UpperCamelCase   ,     return_tensors="""np"""   ,     )
         lowerCAmelCase__      :			List[Any]   =	input_a[input_name]

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

         lowerCAmelCase__      :			Optional[int]   =	pad_max_length if pad_max_length % 10 == 0 else (pad_max_length // 10 + 1) * 10
         self.assertTrue(all(len(UpperCamelCase   ) == 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
         lowerCAmelCase__      :			str   =	(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 	_lowerCAmelCase   (		self       :		Optional[Any]   ,     UpperCamelCase       :		int=False   )			->						List[str]:

         """simple docstring"""
         def _inputs_have_equal_length(UpperCamelCase       :		List[Any]   ):
               lowerCAmelCase__      :			List[str]   =	len(input[0]   )
               for input_slice in input[1:]:
                     if len(UpperCamelCase   ) != length:
                           return False
               return True

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

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

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

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

         # truncate to smallest
         lowerCAmelCase__      :			str   =	feat_extract.pad(
             UpperCamelCase   ,     padding="""max_length"""   ,     max_length=len(speech_inputs[0]   )   ,     truncation=UpperCamelCase   )
         lowerCAmelCase__      :			Dict   =	input_a[input_name]

         lowerCAmelCase__      :			str   =	feat_extract.pad(UpperCamelCase   ,     padding="""max_length"""   ,     max_length=len(speech_inputs[0]   )   )
         lowerCAmelCase__      :			Optional[int]   =	input_a[input_name]

         self.assertTrue(_inputs_have_equal_length(UpperCamelCase   )   )
         self.assertFalse(_inputs_have_equal_length(UpperCamelCase   )   )

         # truncate to smallest with np
         lowerCAmelCase__      :			Tuple   =	feat_extract.pad(
             UpperCamelCase   ,     padding="""max_length"""   ,     max_length=len(speech_inputs[0]   )   ,     return_tensors="""np"""   ,     truncation=UpperCamelCase   ,     )
         lowerCAmelCase__      :			List[Any]   =	input_a[input_name]

         lowerCAmelCase__      :			List[Any]   =	feat_extract.pad(
             UpperCamelCase   ,     padding="""max_length"""   ,     max_length=len(speech_inputs[0]   )   ,     return_tensors="""np"""   )
         lowerCAmelCase__      :			Union[str, Any]   =	input_a[input_name]

         self.assertTrue(_inputs_have_equal_length(UpperCamelCase   )   )
         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(UpperCamelCase   )   )

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

         lowerCAmelCase__      :			List[Any]   =	feat_extract.pad(
             UpperCamelCase   ,     padding="""max_length"""   ,     max_length=len(speech_inputs[1]   )   ,     truncation=UpperCamelCase   )
         lowerCAmelCase__      :			List[str]   =	input_a[input_name]

         lowerCAmelCase__      :			Any   =	feat_extract.pad(
             UpperCamelCase   ,     padding="""max_length"""   ,     max_length=len(speech_inputs[1]   )   ,     return_tensors="""np"""   )
         lowerCAmelCase__      :			Dict   =	input_a[input_name]

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

         # 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(UpperCamelCase   )   )
         self.assertTrue(len(input_a[-1]   ) == len(speech_inputs[-1]   )   )

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

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

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

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

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

         lowerCAmelCase__      :			Any   =	feat_extract.pad(
             UpperCamelCase   ,     padding="""max_length"""   ,     max_length=len(speech_inputs[0]   )   ,     pad_to_multiple_of=UpperCamelCase   ,     )
         lowerCAmelCase__      :			Optional[Any]   =	input_a[input_name]

         # retrieve expected_length as multiple of pad_to_multiple_of
         lowerCAmelCase__      :			Union[str, Any]   =	len(speech_inputs[0]   )
         if expected_length % pad_to_multiple_of != 0:
               lowerCAmelCase__      :			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(UpperCamelCase   )   )
         self.assertFalse(_inputs_have_equal_length(UpperCamelCase   )   )






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

         """simple docstring"""
         self._check_padding(numpify=UpperCamelCase   )






   def 	_lowerCAmelCase   (		self       :		List[Any]   )			->						List[Any]:

         """simple docstring"""
         self._check_padding(numpify=UpperCamelCase   )






   def 	_lowerCAmelCase   (		self       :		Dict   )			->						Optional[int]:

         """simple docstring"""
         self._check_truncation(numpify=UpperCamelCase   )






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

         """simple docstring"""
         self._check_truncation(numpify=UpperCamelCase   )






   @require_torch
   def 	_lowerCAmelCase   (		self       :		Optional[int]   )			->						str:

         """simple docstring"""
         lowerCAmelCase__      :			int   =	self.feature_extraction_class(**self.feat_extract_dict   )
         lowerCAmelCase__      :			str   =	self.feat_extract_tester.prepare_inputs_for_common()
         lowerCAmelCase__      :			str   =	feat_extract.model_input_names[0]

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

         lowerCAmelCase__      :			Dict   =	feat_extract.pad(UpperCamelCase   ,     padding="""longest"""   ,     return_tensors="""np"""   )[input_name]
         lowerCAmelCase__      :			str   =	feat_extract.pad(UpperCamelCase   ,     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 	_lowerCAmelCase   (		self       :		Optional[Any]   )			->						str:

         """simple docstring"""
         lowerCAmelCase__      :			Tuple   =	self.feature_extraction_class(**self.feat_extract_dict   )
         lowerCAmelCase__      :			Tuple   =	self.feat_extract_tester.prepare_inputs_for_common()
         lowerCAmelCase__      :			List[Any]   =	feat_extract.model_input_names[0]

         lowerCAmelCase__      :			int   =	BatchFeature({input_name: speech_inputs}   )

         lowerCAmelCase__      :			int   =	feat_extract.pad(UpperCamelCase   ,     padding="""longest"""   ,     return_tensors="""np"""   )[input_name]
         lowerCAmelCase__      :			Any   =	feat_extract.pad(UpperCamelCase   ,     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 	_lowerCAmelCase   (		self       :		List[Any]   )			->						int:

         """simple docstring"""
         lowerCAmelCase__      :			Any   =	self.feat_extract_dict
         lowerCAmelCase__      :			int   =	True
         lowerCAmelCase__      :			str   =	self.feature_extraction_class(**UpperCamelCase   )
         lowerCAmelCase__      :			int   =	self.feat_extract_tester.prepare_inputs_for_common()
         lowerCAmelCase__      :			List[Any]   =	[len(UpperCamelCase   ) for x in speech_inputs]
         lowerCAmelCase__      :			Optional[Any]   =	feat_extract.model_input_names[0]

         lowerCAmelCase__      :			List[str]   =	BatchFeature({input_name: speech_inputs}   )

         lowerCAmelCase__      :			Tuple   =	feat_extract.pad(UpperCamelCase   ,     padding="""longest"""   ,     return_tensors="""np"""   )
         self.assertIn("""attention_mask"""   ,     UpperCamelCase   )
         self.assertListEqual(list(processed.attention_mask.shape   )   ,     list(processed[input_name].shape[:2]   )   )
         self.assertListEqual(processed.attention_mask.sum(-1   ).tolist()   ,     UpperCamelCase   )






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

         """simple docstring"""
         lowerCAmelCase__      :			Union[str, Any]   =	self.feat_extract_dict
         lowerCAmelCase__      :			List[Any]   =	True
         lowerCAmelCase__      :			str   =	self.feature_extraction_class(**UpperCamelCase   )
         lowerCAmelCase__      :			int   =	self.feat_extract_tester.prepare_inputs_for_common()
         lowerCAmelCase__      :			Any   =	[len(UpperCamelCase   ) for x in speech_inputs]
         lowerCAmelCase__      :			int   =	feat_extract.model_input_names[0]

         lowerCAmelCase__      :			Optional[Any]   =	BatchFeature({input_name: speech_inputs}   )
         lowerCAmelCase__      :			Any   =	min(UpperCamelCase   )

         lowerCAmelCase__      :			Tuple   =	feat_extract.pad(
             UpperCamelCase   ,     padding="""max_length"""   ,     max_length=UpperCamelCase   ,     truncation=UpperCamelCase   ,     return_tensors="""np"""   )
         self.assertIn("""attention_mask"""   ,     UpperCamelCase   )
         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]   )





