"""simple docstring"""



from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available


__magic_name__     					=       {
    """configuration_xlm""": ["""XLM_PRETRAINED_CONFIG_ARCHIVE_MAP""", """XLMConfig""", """XLMOnnxConfig"""],
    """tokenization_xlm""": ["""XLMTokenizer"""],
}

try:
     if not is_torch_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     __magic_name__     					=       [
         """XLM_PRETRAINED_MODEL_ARCHIVE_LIST""",
         """XLMForMultipleChoice""",
         """XLMForQuestionAnswering""",
         """XLMForQuestionAnsweringSimple""",
         """XLMForSequenceClassification""",
         """XLMForTokenClassification""",
         """XLMModel""",
         """XLMPreTrainedModel""",
         """XLMWithLMHeadModel""",
     ]

try:
     if not is_tf_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     __magic_name__     					=       [
         """TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST""",
         """TFXLMForMultipleChoice""",
         """TFXLMForQuestionAnsweringSimple""",
         """TFXLMForSequenceClassification""",
         """TFXLMForTokenClassification""",
         """TFXLMMainLayer""",
         """TFXLMModel""",
         """TFXLMPreTrainedModel""",
         """TFXLMWithLMHeadModel""",
     ]


if TYPE_CHECKING:
     from .configuration_xlm import XLM_PRETRAINED_CONFIG_ARCHIVE_MAP, XLMConfig, XLMOnnxConfig
     from .tokenization_xlm import XLMTokenizer

     try:
          if not is_torch_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_xlm import (
              XLM_PRETRAINED_MODEL_ARCHIVE_LIST,
              XLMForMultipleChoice,
              XLMForQuestionAnswering,
              XLMForQuestionAnsweringSimple,
              XLMForSequenceClassification,
              XLMForTokenClassification,
              XLMModel,
              XLMPreTrainedModel,
              XLMWithLMHeadModel,
          )

     try:
          if not is_tf_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_tf_xlm import (
              TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST,
              TFXLMForMultipleChoice,
              TFXLMForQuestionAnsweringSimple,
              TFXLMForSequenceClassification,
              TFXLMForTokenClassification,
              TFXLMMainLayer,
              TFXLMModel,
              TFXLMPreTrainedModel,
              TFXLMWithLMHeadModel,
          )

else:
     import sys

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









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_  (  snake_case__							):
					# to overwrite at feature extractactor specific tests
					_a      :						str						    =					None
					_a      :						Tuple						    =					None



					@property
					def   __a     (		self     :     str						):
							return self.feat_extract_tester.prepare_feat_extract_dict()



					def   __a     (		self     :     int						):
							lowerCamelCase_	:     List[str] 						=      self.feature_extraction_class(**self.feat_extract_dict						)
							self.assertTrue(hasattr(lowerCamelCase       ,      'feature_size'						)						)
							self.assertTrue(hasattr(lowerCamelCase       ,      'sampling_rate'						)						)
							self.assertTrue(hasattr(lowerCamelCase       ,      'padding_value'						)						)



					def   __a     (		self     :     List[Any]						):
							lowerCamelCase_	:     Dict 						=      self.feat_extract_tester.prepare_inputs_for_common()
							lowerCamelCase_	:     str 						=      self.feature_extraction_class(**self.feat_extract_dict						)
							lowerCamelCase_	:     int 						=      feat_extract.model_input_names[0]

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

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

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

							lowerCamelCase_	:     int 						=      processed_features[input_name]

							if len(batch_features_input.shape						) < 3:
									lowerCamelCase_	:     Union[str, 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)						)



					@require_torch
					def   __a     (		self     :     Dict						):
							lowerCamelCase_	:     Any 						=      self.feat_extract_tester.prepare_inputs_for_common(equal_length=lowerCamelCase						)
							lowerCamelCase_	:     List[Any] 						=      self.feature_extraction_class(**self.feat_extract_dict						)
							lowerCamelCase_	:     Tuple 						=      feat_extract.model_input_names[0]

							lowerCamelCase_	:     Any 						=      BatchFeature({input_name: speech_inputs}       ,      tensor_type='pt'						)

							lowerCamelCase_	:     Optional[int] 						=      processed_features[input_name]

							if len(batch_features_input.shape						) < 3:
									lowerCamelCase_	:     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_tf
					def   __a     (		self     :     Tuple						):
							lowerCamelCase_	:     int 						=      self.feat_extract_tester.prepare_inputs_for_common(equal_length=lowerCamelCase						)
							lowerCamelCase_	:     List[str] 						=      self.feature_extraction_class(**self.feat_extract_dict						)
							lowerCamelCase_	:     int 						=      feat_extract.model_input_names[0]

							lowerCamelCase_	:     List[str] 						=      BatchFeature({input_name: speech_inputs}       ,      tensor_type='tf'						)

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

							if len(batch_features_input.shape						) < 3:
									lowerCamelCase_	:     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   __a     (		self     :     Optional[Any]       ,      lowerCamelCase     :     int=False						):
							def _inputs_have_equal_length(lowerCamelCase     :     Union[str, Any]						):
									lowerCamelCase_	:     Any 						=      len(input[0]						)
									for input_slice in input[1:]:
											if len(lowerCamelCase						) != length:
													return False
									return True

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

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

							lowerCamelCase_	:     List[str] 						=      self.feature_extraction_class(**self.feat_extract_dict						)
							lowerCamelCase_	:     str 						=      self.feat_extract_tester.prepare_inputs_for_common(numpify=lowerCamelCase						)
							lowerCamelCase_	:     List[Any] 						=      feat_extract.model_input_names[0]

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

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

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

							lowerCamelCase_	:     List[str] 						=      feat_extract.pad(lowerCamelCase       ,      padding='longest'						)
							lowerCamelCase_	:     Optional[Any] 						=      input_a[input_name]

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

							lowerCamelCase_	:     Union[str, Any] 						=      feat_extract.pad(lowerCamelCase       ,      padding='longest'       ,      return_tensors='np'						)
							lowerCamelCase_	:     int 						=      input_a[input_name]

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

							lowerCamelCase_	:     Union[str, Any] 						=      feat_extract.pad(
							    lowerCamelCase       ,      padding='max_length'       ,      max_length=lowerCamelCase       ,      return_tensors='np'						)
							lowerCamelCase_	:     Dict 						=      input_a[input_name]

							self.assertFalse(_inputs_have_equal_length(lowerCamelCase						)						)
							self.assertTrue(_inputs_have_equal_length(lowerCamelCase						)						)
							self.assertTrue(_inputs_have_equal_length(lowerCamelCase						)						)
							self.assertTrue(_inputs_are_equal(lowerCamelCase       ,      lowerCamelCase						)						)
							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_	:     Optional[Any] 						=      feat_extract.pad(lowerCamelCase       ,      pad_to_multiple_of=10						)
							lowerCamelCase_	:     Dict 						=      input_a[input_name]

							lowerCamelCase_	:     List[Any] 						=      feat_extract.pad(lowerCamelCase       ,      padding='longest'       ,      pad_to_multiple_of=10						)
							lowerCamelCase_	:     Union[str, Any] 						=      input_a[input_name]

							lowerCamelCase_	:     str 						=      feat_extract.pad(
							    lowerCamelCase       ,      padding='max_length'       ,      pad_to_multiple_of=10       ,      max_length=lowerCamelCase						)
							lowerCamelCase_	:     List[str] 						=      input_a[input_name]

							lowerCamelCase_	:     Any 						=      feat_extract.pad(
							    lowerCamelCase       ,      padding='max_length'       ,      pad_to_multiple_of=10       ,      max_length=lowerCamelCase       ,      return_tensors='np'       ,      )
							lowerCamelCase_	:     str 						=      input_a[input_name]

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

							lowerCamelCase_	:     Dict 						=      pad_max_length if pad_max_length % 10 == 0 else (pad_max_length // 10 + 1) * 10
							self.assertTrue(all(len(lowerCamelCase						) == 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_	:     Dict 						=      (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   __a     (		self     :     Optional[Any]       ,      lowerCamelCase     :     Any=False						):
							def _inputs_have_equal_length(lowerCamelCase     :     Dict						):
									lowerCamelCase_	:     Dict 						=      len(input[0]						)
									for input_slice in input[1:]:
											if len(lowerCamelCase						) != length:
													return False
									return True

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

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

							lowerCamelCase_	:     List[str] 						=      self.feature_extraction_class(**self.feat_extract_dict						)
							lowerCamelCase_	:     str 						=      self.feat_extract_tester.prepare_inputs_for_common(numpify=lowerCamelCase						)
							lowerCamelCase_	:     Any 						=      feat_extract.model_input_names[0]

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

							# truncate to smallest
							lowerCamelCase_	:     Dict 						=      feat_extract.pad(
							    lowerCamelCase       ,      padding='max_length'       ,      max_length=len(speech_inputs[0]						)       ,      truncation=lowerCamelCase						)
							lowerCamelCase_	:     int 						=      input_a[input_name]

							lowerCamelCase_	:     str 						=      feat_extract.pad(lowerCamelCase       ,      padding='max_length'       ,      max_length=len(speech_inputs[0]						)						)
							lowerCamelCase_	:     Union[str, Any] 						=      input_a[input_name]

							self.assertTrue(_inputs_have_equal_length(lowerCamelCase						)						)
							self.assertFalse(_inputs_have_equal_length(lowerCamelCase						)						)

							# truncate to smallest with np
							lowerCamelCase_	:     Optional[int] 						=      feat_extract.pad(
							    lowerCamelCase       ,      padding='max_length'       ,      max_length=len(speech_inputs[0]						)       ,      return_tensors='np'       ,      truncation=lowerCamelCase       ,      )
							lowerCamelCase_	:     List[str] 						=      input_a[input_name]

							lowerCamelCase_	:     int 						=      feat_extract.pad(
							    lowerCamelCase       ,      padding='max_length'       ,      max_length=len(speech_inputs[0]						)       ,      return_tensors='np'						)
							lowerCamelCase_	:     Tuple 						=      input_a[input_name]

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

							# truncate to middle
							lowerCamelCase_	:     Tuple 						=      feat_extract.pad(
							    lowerCamelCase       ,      padding='max_length'       ,      max_length=len(speech_inputs[1]						)       ,      truncation=lowerCamelCase       ,      return_tensors='np'       ,      )
							lowerCamelCase_	:     Union[str, Any] 						=      input_a[input_name]

							lowerCamelCase_	:     str 						=      feat_extract.pad(
							    lowerCamelCase       ,      padding='max_length'       ,      max_length=len(speech_inputs[1]						)       ,      truncation=lowerCamelCase						)
							lowerCamelCase_	:     Any 						=      input_a[input_name]

							lowerCamelCase_	:     int 						=      feat_extract.pad(
							    lowerCamelCase       ,      padding='max_length'       ,      max_length=len(speech_inputs[1]						)       ,      return_tensors='np'						)
							lowerCamelCase_	:     Optional[int] 						=      input_a[input_name]

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

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

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

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

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

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

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

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

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



					def   __a     (		self     :     Any						):
							self._check_padding(numpify=lowerCamelCase						)



					def   __a     (		self     :     List[Any]						):
							self._check_padding(numpify=lowerCamelCase						)



					def   __a     (		self     :     int						):
							self._check_truncation(numpify=lowerCamelCase						)



					def   __a     (		self     :     Optional[int]						):
							self._check_truncation(numpify=lowerCamelCase						)



					@require_torch
					def   __a     (		self     :     str						):
							lowerCamelCase_	:     List[Any] 						=      self.feature_extraction_class(**self.feat_extract_dict						)
							lowerCamelCase_	:     str 						=      self.feat_extract_tester.prepare_inputs_for_common()
							lowerCamelCase_	:     Optional[Any] 						=      feat_extract.model_input_names[0]

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

							lowerCamelCase_	:     int 						=      feat_extract.pad(lowerCamelCase       ,      padding='longest'       ,      return_tensors='np'						)[input_name]
							lowerCamelCase_	:     Dict 						=      feat_extract.pad(lowerCamelCase       ,      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   __a     (		self     :     Any						):
							lowerCamelCase_	:     Union[str, Any] 						=      self.feature_extraction_class(**self.feat_extract_dict						)
							lowerCamelCase_	:     List[str] 						=      self.feat_extract_tester.prepare_inputs_for_common()
							lowerCamelCase_	:     Tuple 						=      feat_extract.model_input_names[0]

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

							lowerCamelCase_	:     Dict 						=      feat_extract.pad(lowerCamelCase       ,      padding='longest'       ,      return_tensors='np'						)[input_name]
							lowerCamelCase_	:     List[str] 						=      feat_extract.pad(lowerCamelCase       ,      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   __a     (		self     :     str						):
							lowerCamelCase_	:     Any 						=      self.feat_extract_dict
							lowerCamelCase_	:     Optional[Any] 						=      True
							lowerCamelCase_	:     Dict 						=      self.feature_extraction_class(**lowerCamelCase						)
							lowerCamelCase_	:     Optional[int] 						=      self.feat_extract_tester.prepare_inputs_for_common()
							lowerCamelCase_	:     List[str] 						=      [len(lowerCamelCase						) for x in speech_inputs]
							lowerCamelCase_	:     List[Any] 						=      feat_extract.model_input_names[0]

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

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





					def   __a     (		self     :     Dict						):
							lowerCamelCase_	:     int 						=      self.feat_extract_dict
							lowerCamelCase_	:     Any 						=      True
							lowerCamelCase_	:     int 						=      self.feature_extraction_class(**lowerCamelCase						)
							lowerCamelCase_	:     List[str] 						=      self.feat_extract_tester.prepare_inputs_for_common()
							lowerCamelCase_	:     str 						=      [len(lowerCamelCase						) for x in speech_inputs]
							lowerCamelCase_	:     Optional[Any] 						=      feat_extract.model_input_names[0]

							lowerCamelCase_	:     Any 						=      BatchFeature({input_name: speech_inputs}						)
							lowerCamelCase_	:     Optional[Any] 						=      min(lowerCamelCase						)

							lowerCamelCase_	:     List[Any] 						=      feat_extract.pad(
							    lowerCamelCase       ,      padding='max_length'       ,      max_length=lowerCamelCase       ,      truncation=lowerCamelCase       ,      return_tensors='np'						)
							self.assertIn('attention_mask'       ,      lowerCamelCase						)
							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]						)
